Function structTypeOf

proto/reflect.go:357–424

(t reflect.Type, seen map[reflect.Type]Type)

}

func structTypeOf(t reflect.Type, seen map[reflect.Type]Type) *structType {
	st := &structType{
		name:           t.Name(),
		fieldsByName:   make(map[string]int),
		fieldsByNumber: make(map[FieldNumber]int),
	}

	seen[t] = st

	fieldNumber := FieldNumber(0)
	taggedFields := FieldNumber(0)

	for i := range t.NumField() {
		f := t.Field(i)

		if f.PkgPath != "" {
			continue // unexported
		}

		repeated := false
		if f.Type.Kind() == reflect.Slice && f.Type.Elem().Kind() != reflect.Uint8 {
			repeated = true
			f.Type = f.Type.Elem() // for typeOf
		}

		fieldName := f.Name
		fieldType := typeOf(f.Type, seen)

		if tag, ok := f.Tag.Lookup("protobuf"); ok {
			if fieldNumber != taggedFields {
				panic("conflicting use of struct tag and naked fields")
			}
			t, err := parseStructTag(tag)
			if err != nil {
				panic(err)
			}

			fieldName = t.name
			fieldNumber = t.fieldNumber
			taggedFields = t.fieldNumber
			// Because maps are represented as repeated varlen fields on the
			// wire, the generated protobuf code sets the `rep` attribute on
			// the struct fields.
			repeated = t.repeated && f.Type.Kind() != reflect.Map

			if t.zigzag {
				fieldType = fieldType.ZigZag()
			}
		} else if fieldNumber == 0 && len(st.fields) != 0 {
			panic("conflicting use of struct tag and naked fields")
		} else {
			fieldNumber++
		}

		index := len(st.fields)
		st.fields = append(st.fields, Field{
			Index:    index,
			Number:   fieldNumber,