Method decode

thrift/decode.go:368–447

(r Reader, v reflect.Value, flags flags)

}

func (dec *structDecoder) decode(r Reader, v reflect.Value, flags flags) error {
	flags = flags.only(decodeFlags)
	coalesceBoolFields := flags.have(coalesceBoolFields)

	lastField := reflect.Value{}
	union := len(dec.union) > 0
	seen := make([]uint64, 1)
	if len(dec.required) > len(seen) {
		seen = make([]uint64, len(dec.required))
	}

	err := readStruct(r, func(r Reader, f Field) error {
		i := int(f.ID) - int(dec.minID)
		if i < 0 || i >= len(dec.fields) || dec.fields[i].decode == nil {
			return skipField(r, f)
		}
		field := &dec.fields[i]
		seen[i/64] |= 1 << (i % 64)

		// TODO: implement type conversions?
		if f.Type != field.typ && (f.Type != TRUE || field.typ != BOOL) {
			if flags.have(strict) {
				return &TypeMismatch{item: "field value", Expect: field.typ, Found: f.Type}
			}
			return nil
		}

		x := v
		for _, i := range field.index {
			if x.Kind() == reflect.Ptr {
				x = x.Elem()
			}
			if x = x.Field(i); x.Kind() == reflect.Ptr {
				if x.IsNil() {
					x.Set(reflect.New(x.Type().Elem()))
				}
			}
		}

		if union {
			v.Set(dec.zero)
		}

		lastField = x

		if coalesceBoolFields && (f.Type == TRUE || f.Type == FALSE) {
			for x.Kind() == reflect.Ptr {
				if x.IsNil() {
					x.Set(reflect.New(x.Type().Elem()))
				}
				x = x.Elem()
			}
			x.SetBool(f.Type == TRUE)
			return nil
		}

		return field.decode(r, x, flags.with(field.flags))
	})