Function decodeReflectList

libs/json/decoder.go:101–148

(bz []byte, rv reflect.Value)

}

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

	switch rv.Type().Elem().Kind() {
	// Decode base64-encoded bytes using stdlib decoder, via byte slice for arrays.
	case reflect.Uint8:
		if rv.Type().Kind() == reflect.Array {
			var buf []byte
			if err := json.Unmarshal(bz, &buf); err != nil {
				return err
			}
			if len(buf) != rv.Len() {
				return fmt.Errorf("got %v bytes, expected %v", len(buf), rv.Len())
			}
			reflect.Copy(rv, reflect.ValueOf(buf))

		} else if err := decodeStdlib(bz, rv); err != nil {
			return err
		}

	// Decode anything else into a raw JSON slice, and decode values recursively.
	default:
		var rawSlice []json.RawMessage
		if err := json.Unmarshal(bz, &rawSlice); err != nil {
			return err
		}
		if rv.Type().Kind() == reflect.Slice {
			rv.Set(reflect.MakeSlice(reflect.SliceOf(rv.Type().Elem()), len(rawSlice), len(rawSlice)))
		}
		if rv.Len() != len(rawSlice) { // arrays of wrong size
			return fmt.Errorf("got list of %v elements, expected %v", len(rawSlice), rv.Len())
		}
		for i, bz := range rawSlice {
			if err := decodeReflect(bz, rv.Index(i)); err != nil {
				return err
			}
		}
	}

	// Replace empty slices with nil slices, for Amino compatibility
	if rv.Type().Kind() == reflect.Slice && rv.Len() == 0 {
		rv.Set(reflect.Zero(rv.Type()))
	}

	return nil
}

func decodeReflectMap(bz []byte, rv reflect.Value) error {
	if !rv.CanAddr() {