Function decodeReflectInterface

libs/json/decoder.go:204–256

(bz []byte, rv reflect.Value)

}

func decodeReflectInterface(bz []byte, rv reflect.Value) error {
	if !rv.CanAddr() {
		return errors.New("interface value not addressable")
	}

	// Decode the interface wrapper.
	wrapper := interfaceWrapper{}
	if err := json.Unmarshal(bz, &wrapper); err != nil {
		return err
	}
	if wrapper.Type == "" {
		return errors.New("interface type cannot be empty")
	}
	if len(wrapper.Value) == 0 {
		return errors.New("interface value cannot be empty")
	}

	// Dereference-and-construct pointers, to handle nested pointers.
	for rv.Kind() == reflect.Ptr {
		if rv.IsNil() {
			rv.Set(reflect.New(rv.Type().Elem()))
		}
		rv = rv.Elem()
	}

	// Look up the interface type, and construct a concrete value.
	rt, returnPtr := typeRegistry.lookup(wrapper.Type)
	if rt == nil {
		return fmt.Errorf("unknown type %q", wrapper.Type)
	}

	cptr := reflect.New(rt)
	crv := cptr.Elem()
	if err := decodeReflect(wrapper.Value, crv); err != nil {
		return err
	}

	// This makes sure interface implementations with pointer receivers (e.g. func (c *Car)) are
	// constructed as pointers behind the interface. The types must be registered as pointers with
	// RegisterType().
	if rv.Type().Kind() == reflect.Interface && returnPtr {
		if !cptr.Type().AssignableTo(rv.Type()) {
			return fmt.Errorf("invalid type %q for this value", wrapper.Type)
		}
		rv.Set(cptr)
	} else {
		if !crv.Type().AssignableTo(rv.Type()) {
			return fmt.Errorf("invalid type %q for this value", wrapper.Type)
		}
		rv.Set(crv)
	}
	return nil
}

func decodeStdlib(bz []byte, rv reflect.Value) error {
	if !rv.CanAddr() && rv.Kind() != reflect.Ptr {