func()

in extra/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go [229:317]
83 lines of code
24 McCabe index (conditional complexity)

func (u unmarshaler) unmarshalScalar(value reflect.Value, data interface{}, tag reflect.StructTag) error {

	switch d := data.(type) {
	case nil:
		return nil // nothing to do here
	case string:
		switch value.Interface().(type) {
		case *string:
			value.Set(reflect.ValueOf(&d))
		case []byte:
			b, err := base64.StdEncoding.DecodeString(d)
			if err != nil {
				return err
			}
			value.Set(reflect.ValueOf(b))
		case *time.Time:
			format := tag.Get("timestampFormat")
			if len(format) == 0 {
				format = protocol.ISO8601TimeFormatName
			}

			t, err := protocol.ParseTime(format, d)
			if err != nil {
				return err
			}
			value.Set(reflect.ValueOf(&t))
		case aws.JSONValue:
			// No need to use escaping as the value is a non-quoted string.
			v, err := protocol.DecodeJSONValue(d, protocol.NoEscape)
			if err != nil {
				return err
			}
			value.Set(reflect.ValueOf(v))
		case *float64:
			// These are regular strings when parsed by encoding/json's unmarshaler.
			switch {
			case strings.EqualFold(d, floatNaN):
				value.Set(reflect.ValueOf(aws.Float64(math.NaN())))
			case strings.EqualFold(d, floatInf):
				value.Set(reflect.ValueOf(aws.Float64(math.Inf(1))))
			case strings.EqualFold(d, floatNegInf):
				value.Set(reflect.ValueOf(aws.Float64(math.Inf(-1))))
			default:
				return fmt.Errorf("unknown JSON number value: %s", d)
			}
		default:
			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		}
	case json.Number:
		switch value.Interface().(type) {
		case *int64:
			// Retain the old behavior where we would just truncate the float64
			// calling d.Int64() here could cause an invalid syntax error due to the usage of strconv.ParseInt
			f, err := d.Float64()
			if err != nil {
				return err
			}
			di := int64(f)
			value.Set(reflect.ValueOf(&di))
		case *float64:
			f, err := d.Float64()
			if err != nil {
				return err
			}
			value.Set(reflect.ValueOf(&f))
		case *time.Time:
			float, ok := new(big.Float).SetString(d.String())
			if !ok {
				return fmt.Errorf("unsupported float time representation: %v", d.String())
			}
			float = float.Mul(float, millisecondsFloat)
			ms, _ := float.Int64()
			t := time.Unix(0, ms*1e6).UTC()
			value.Set(reflect.ValueOf(&t))
		default:
			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		}
	case bool:
		switch value.Interface().(type) {
		case *bool:
			value.Set(reflect.ValueOf(&d))
		default:
			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		}
	default:
		return fmt.Errorf("unsupported JSON value (%v)", data)
	}
	return nil
}