summaryrefslogtreecommitdiff
path: root/vendor/github.com/goccy/go-json/internal/decoder/assign.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/goccy/go-json/internal/decoder/assign.go')
-rw-r--r--vendor/github.com/goccy/go-json/internal/decoder/assign.go438
1 files changed, 0 insertions, 438 deletions
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/assign.go b/vendor/github.com/goccy/go-json/internal/decoder/assign.go
deleted file mode 100644
index c53e6ad9f..000000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/assign.go
+++ /dev/null
@@ -1,438 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "strconv"
-)
-
-var (
- nilValue = reflect.ValueOf(nil)
-)
-
-func AssignValue(src, dst reflect.Value) error {
- if dst.Type().Kind() != reflect.Ptr {
- return fmt.Errorf("invalid dst type. required pointer type: %T", dst.Type())
- }
- casted, err := castValue(dst.Elem().Type(), src)
- if err != nil {
- return err
- }
- dst.Elem().Set(casted)
- return nil
-}
-
-func castValue(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- switch t.Kind() {
- case reflect.Int:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int(vv.Int())), nil
- case reflect.Int8:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int8(vv.Int())), nil
- case reflect.Int16:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int16(vv.Int())), nil
- case reflect.Int32:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int32(vv.Int())), nil
- case reflect.Int64:
- return castInt(v)
- case reflect.Uint:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint(vv.Uint())), nil
- case reflect.Uint8:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint8(vv.Uint())), nil
- case reflect.Uint16:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint16(vv.Uint())), nil
- case reflect.Uint32:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint32(vv.Uint())), nil
- case reflect.Uint64:
- return castUint(v)
- case reflect.Uintptr:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uintptr(vv.Uint())), nil
- case reflect.String:
- return castString(v)
- case reflect.Bool:
- return castBool(v)
- case reflect.Float32:
- vv, err := castFloat(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(float32(vv.Float())), nil
- case reflect.Float64:
- return castFloat(v)
- case reflect.Array:
- return castArray(t, v)
- case reflect.Slice:
- return castSlice(t, v)
- case reflect.Map:
- return castMap(t, v)
- case reflect.Struct:
- return castStruct(t, v)
- }
- return v, nil
-}
-
-func castInt(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v, nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(int64(v.Uint())), nil
- case reflect.String:
- i64, err := strconv.ParseInt(v.String(), 10, 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(i64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(int64(1)), nil
- }
- return reflect.ValueOf(int64(0)), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(int64(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castInt(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castInt(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from empty slice")
- case reflect.Interface:
- return castInt(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to int64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to int64 from struct")
- case reflect.Ptr:
- return castInt(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from %s", v.Type().Kind())
-}
-
-func castUint(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(uint64(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v, nil
- case reflect.String:
- u64, err := strconv.ParseUint(v.String(), 10, 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(u64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(uint64(1)), nil
- }
- return reflect.ValueOf(uint64(0)), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(uint64(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castUint(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castUint(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from empty slice")
- case reflect.Interface:
- return castUint(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to uint64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to uint64 from struct")
- case reflect.Ptr:
- return castUint(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from %s", v.Type().Kind())
-}
-
-func castString(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(fmt.Sprint(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(fmt.Sprint(v.Uint())), nil
- case reflect.String:
- return v, nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf("true"), nil
- }
- return reflect.ValueOf("false"), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(fmt.Sprint(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castString(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castString(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty slice")
- case reflect.Interface:
- return castString(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to string from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to string from struct")
- case reflect.Ptr:
- return castString(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to string from %s", v.Type().Kind())
-}
-
-func castBool(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- switch v.Int() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Int())
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- switch v.Uint() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Uint())
- case reflect.String:
- b, err := strconv.ParseBool(v.String())
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(b), nil
- case reflect.Bool:
- return v, nil
- case reflect.Float32, reflect.Float64:
- switch v.Float() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %f", v.Float())
- case reflect.Array:
- if v.Len() > 0 {
- return castBool(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castBool(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty slice")
- case reflect.Interface:
- return castBool(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to string from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to string from struct")
- case reflect.Ptr:
- return castBool(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %s", v.Type().Kind())
-}
-
-func castFloat(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(float64(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(float64(v.Uint())), nil
- case reflect.String:
- f64, err := strconv.ParseFloat(v.String(), 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(f64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(float64(1)), nil
- }
- return reflect.ValueOf(float64(0)), nil
- case reflect.Float32, reflect.Float64:
- return v, nil
- case reflect.Array:
- if v.Len() > 0 {
- return castFloat(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castFloat(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from empty slice")
- case reflect.Interface:
- return castFloat(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to float64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to float64 from struct")
- case reflect.Ptr:
- return castFloat(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from %s", v.Type().Kind())
-}
-
-func castArray(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- kind := v.Type().Kind()
- if kind == reflect.Interface {
- return castArray(t, reflect.ValueOf(v.Interface()))
- }
- if kind != reflect.Slice && kind != reflect.Array {
- return nilValue, fmt.Errorf("failed to cast to array from %s", kind)
- }
- if t.Elem() == v.Type().Elem() {
- return v, nil
- }
- if t.Len() != v.Len() {
- return nilValue, fmt.Errorf("failed to cast [%d]array from slice of %d length", t.Len(), v.Len())
- }
- ret := reflect.New(t).Elem()
- for i := 0; i < v.Len(); i++ {
- vv, err := castValue(t.Elem(), v.Index(i))
- if err != nil {
- return nilValue, err
- }
- ret.Index(i).Set(vv)
- }
- return ret, nil
-}
-
-func castSlice(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- kind := v.Type().Kind()
- if kind == reflect.Interface {
- return castSlice(t, reflect.ValueOf(v.Interface()))
- }
- if kind != reflect.Slice && kind != reflect.Array {
- return nilValue, fmt.Errorf("failed to cast to slice from %s", kind)
- }
- if t.Elem() == v.Type().Elem() {
- return v, nil
- }
- ret := reflect.MakeSlice(t, v.Len(), v.Len())
- for i := 0; i < v.Len(); i++ {
- vv, err := castValue(t.Elem(), v.Index(i))
- if err != nil {
- return nilValue, err
- }
- ret.Index(i).Set(vv)
- }
- return ret, nil
-}
-
-func castMap(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- ret := reflect.MakeMap(t)
- switch v.Type().Kind() {
- case reflect.Map:
- iter := v.MapRange()
- for iter.Next() {
- key, err := castValue(t.Key(), iter.Key())
- if err != nil {
- return nilValue, err
- }
- value, err := castValue(t.Elem(), iter.Value())
- if err != nil {
- return nilValue, err
- }
- ret.SetMapIndex(key, value)
- }
- return ret, nil
- case reflect.Interface:
- return castMap(t, reflect.ValueOf(v.Interface()))
- case reflect.Slice:
- if v.Len() > 0 {
- return castMap(t, v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to map from empty slice")
- }
- return nilValue, fmt.Errorf("failed to cast to map from %s", v.Type().Kind())
-}
-
-func castStruct(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- ret := reflect.New(t).Elem()
- switch v.Type().Kind() {
- case reflect.Map:
- iter := v.MapRange()
- for iter.Next() {
- key := iter.Key()
- k, err := castString(key)
- if err != nil {
- return nilValue, err
- }
- fieldName := k.String()
- field, ok := t.FieldByName(fieldName)
- if ok {
- value, err := castValue(field.Type, iter.Value())
- if err != nil {
- return nilValue, err
- }
- ret.FieldByName(fieldName).Set(value)
- }
- }
- return ret, nil
- case reflect.Struct:
- for i := 0; i < v.Type().NumField(); i++ {
- name := v.Type().Field(i).Name
- ret.FieldByName(name).Set(v.FieldByName(name))
- }
- return ret, nil
- case reflect.Interface:
- return castStruct(t, reflect.ValueOf(v.Interface()))
- case reflect.Slice:
- if v.Len() > 0 {
- return castStruct(t, v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to struct from empty slice")
- default:
- return nilValue, fmt.Errorf("failed to cast to struct from %s", v.Type().Kind())
- }
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-24 21:03:43 +0000