type encoding/gob.typeId

64 uses

	encoding/gob (current package)
		decode.go#L778: var decIgnoreOpMap = map[typeId]decOp{
		decode.go#L790: func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string, inProgress map[reflect.Type]*decOp) *decOp {
		decode.go#L838: 			var elemId typeId
		decode.go#L875: func (dec *Decoder) decIgnoreOpFor(wireId typeId, inProgress map[typeId]*decOp) *decOp {
		decode.go#L969: func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId, inProgress map[reflect.Type]typeId) bool {
		decode.go#L1040: func (dec *Decoder) typeString(remoteId typeId) string {
		decode.go#L1052: func (dec *Decoder) compileSingle(remoteId typeId, ut *userTypeInfo) (engine *decEngine, err error) {
		decode.go#L1057: 	if !dec.compatibleType(rt, remoteId, make(map[reflect.Type]typeId)) {
		decode.go#L1073: func (dec *Decoder) compileIgnoreSingle(remoteId typeId) *decEngine {
		decode.go#L1076: 	op := dec.decIgnoreOpFor(remoteId, make(map[typeId]*decOp))
		decode.go#L1085: func (dec *Decoder) compileDec(remoteId typeId, ut *userTypeInfo) (engine *decEngine, err error) {
		decode.go#L1121: 			op := dec.decIgnoreOpFor(wireField.Id, make(map[typeId]*decOp))
		decode.go#L1125: 		if !dec.compatibleType(localField.Type, wireField.Id, make(map[reflect.Type]typeId)) {
		decode.go#L1136: func (dec *Decoder) getDecEnginePtr(remoteId typeId, ut *userTypeInfo) (enginePtr **decEngine, err error) {
		decode.go#L1140: 		decoderMap = make(map[typeId]**decEngine)
		decode.go#L1161: func (dec *Decoder) getIgnoreEnginePtr(wireId typeId) (enginePtr **decEngine, err error) {
		decode.go#L1181: func (dec *Decoder) decodeValue(wireId typeId, value reflect.Value) {
		decode.go#L1212: func (dec *Decoder) decodeIgnoredValue(wireId typeId) {
		decoder.go#L31: 	wireType     map[typeId]*wireType                    // map from remote ID to local description
		decoder.go#L32: 	decoderCache map[reflect.Type]map[typeId]**decEngine // cache of compiled engines
		decoder.go#L33: 	ignorerCache map[typeId]**decEngine                  // ditto for ignored objects
		decoder.go#L49: 	dec.wireType = make(map[typeId]*wireType)
		decoder.go#L50: 	dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
		decoder.go#L51: 	dec.ignorerCache = make(map[typeId]**decEngine)
		decoder.go#L58: func (dec *Decoder) recvType(id typeId) {
		decoder.go#L140: func (dec *Decoder) decodeTypeSequence(isInterface bool) typeId {
		decoder.go#L148: 		id := typeId(dec.nextInt())
		encoder.go#L20: 	sent       map[reflect.Type]typeId // which types we've already sent
		encoder.go#L37: 	enc.sent = make(map[reflect.Type]typeId)
		type.go#L161: type typeId int32
		type.go#L163: var nextId typeId       // incremented for each new type we build
		type.go#L168: 	id() typeId
		type.go#L169: 	setId(id typeId)
		type.go#L172: 	safeString(seen map[typeId]bool) string
		type.go#L176: var idToType = make(map[typeId]gobType)
		type.go#L177: var builtinIdToType map[typeId]gobType // set in init() after builtins are established
		type.go#L189: func (t typeId) gobType() gobType {
		type.go#L197: func (t typeId) string() string {
		type.go#L205: func (t typeId) name() string {
		type.go#L218: 	Id   typeId
		type.go#L221: func (t *CommonType) id() typeId { return t.Id }
		type.go#L223: func (t *CommonType) setId(id typeId) { t.Id = id }
		type.go#L227: func (t *CommonType) safeString(seen map[typeId]bool) string {
		type.go#L272: 	builtinIdToType = make(map[typeId]gobType)
		type.go#L290: 	Elem typeId
		type.go#L306: func (a *arrayType) safeString(seen map[typeId]bool) string {
		type.go#L314: func (a *arrayType) string() string { return a.safeString(make(map[typeId]bool)) }
		type.go#L327: func (g *gobEncoderType) safeString(seen map[typeId]bool) string {
		type.go#L336: 	Key  typeId
		type.go#L337: 	Elem typeId
		type.go#L352: func (m *mapType) safeString(seen map[typeId]bool) string {
		type.go#L362: func (m *mapType) string() string { return m.safeString(make(map[typeId]bool)) }
		type.go#L367: 	Elem typeId
		type.go#L386: func (s *sliceType) safeString(seen map[typeId]bool) string {
		type.go#L394: func (s *sliceType) string() string { return s.safeString(make(map[typeId]bool)) }
		type.go#L399: 	Id   typeId
		type.go#L407: func (s *structType) safeString(seen map[typeId]bool) string {
		type.go#L423: func (s *structType) string() string { return s.safeString(make(map[typeId]bool)) }
		type.go#L605: func checkId(want, got typeId) {
		type.go#L614: func bootstrapType(name string, e interface{}, expect typeId) typeId {
		type.go#L674: 	id      typeId