Function decodeReflect

libs/json/decoder.go:39–99

(bz []byte, rv reflect.Value)

}

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

	// Handle null for slices, interfaces, and pointers
	if bytes.Equal(bz, []byte("null")) {
		rv.Set(reflect.Zero(rv.Type()))
		return nil
	}

	// 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()
	}

	// Times must be UTC and end with Z
	if rv.Type() == timeType {
		switch {
		case len(bz) < 2 || bz[0] != '"' || bz[len(bz)-1] != '"':
			return fmt.Errorf("JSON time must be an RFC3339 string, but got %q", bz)
		case bz[len(bz)-2] != 'Z':
			return fmt.Errorf("JSON time must be UTC and end with 'Z', but got %q", bz)
		}
	}

	// If value implements json.Umarshaler, call it.
	if rv.Addr().Type().Implements(jsonUnmarshalerType) {
		return rv.Addr().Interface().(json.Unmarshaler).UnmarshalJSON(bz)
	}

	switch rv.Type().Kind() {
	// Decode complex types recursively.
	case reflect.Slice, reflect.Array:
		return decodeReflectList(bz, rv)

	case reflect.Map:
		return decodeReflectMap(bz, rv)

	case reflect.Struct:
		return decodeReflectStruct(bz, rv)

	case reflect.Interface:
		return decodeReflectInterface(bz, rv)

	// For 64-bit integers, unwrap expected string and defer to stdlib for integer decoding.
	case reflect.Int64, reflect.Int, reflect.Uint64, reflect.Uint:
		if bz[0] != '"' || bz[len(bz)-1] != '"' {
			return fmt.Errorf("invalid 64-bit integer encoding %q, expected string", string(bz))
		}
		bz = bz[1 : len(bz)-1]
		fallthrough

	// Anything else we defer to the stdlib.
	default: