go-playground / form / 18239222419

func (d *decoder) setError(namespace []byte, err error) {

        if d.errs == nil {

                d.errs = make(DecodeErrors)

        }

        d.errs[string(namespace)] = err

func (d *decoder) findAlias(ns string) *recursiveData {

        if d.aliasMap != nil {

                return d.aliasMap[ns]

        }

func (d *decoder) parseMapData() {

        // already parsed

        if len(d.dm) > 0 {

                return

        }

        d.maxKeyLen = 0

        d.dm = d.dm[0:0]

        if d.aliasMap == nil {

                d.aliasMap = make(map[string]*recursiveData)

        } else {

                for k := range d.aliasMap {

                        delete(d.aliasMap, k)

                }

        var i int

        var idx int

        var l int

        var insideBracket bool

        var rd *recursiveData

        var isNum bool

        for k := range d.values {

                if len(k) > d.maxKeyLen {

                        d.maxKeyLen = len(k)

                }

                for i = 0; i < len(k); i++ {

                        switch k[i] {

                        case '[':

                                idx = i

                                insideBracket = true

                                isNum = true

                        case ']':

                                if !insideBracket {

                                        log.Panicf(errMissingStartBracket, k)

                                }

                                if rd = d.findAlias(k[:idx]); rd == nil {

                                        l = len(d.dm) + 1

                                        if l > cap(d.dm) {

                                                dm := make(dataMap, l)

                                                copy(dm, d.dm)

                                                rd = new(recursiveData)

                                                dm[len(d.dm)] = rd

                                                d.dm = dm

                                        } else {

                                                l = len(d.dm)

                                                d.dm = d.dm[:l+1]

                                                rd = d.dm[l]

                                                rd.sliceLen = 0

                                                rd.keys = rd.keys[0:0]

                                        }

                                        rd.alias = k[:idx]

                                        d.aliasMap[rd.alias] = rd

                                ke := key{

                                        ivalue:      -1,

                                        value:       k[idx+1 : i],

                                        searchValue: k[idx : i+1],

                                }

                                // is key is number, most likely array key, keep track of just in case an array/slice.

                                if isNum {

                                        // no need to check for error, it will always pass

                                        // as we have done the checking to ensure

                                        // the value is a number ahead of time.

                                        var err error

                                        ke.ivalue, err = strconv.Atoi(ke.value)

                                        if err != nil {

                                                ke.ivalue = -1

                                        }

                                        if ke.ivalue > rd.sliceLen {

                                                rd.sliceLen = ke.ivalue

                                        }

                                rd.keys = append(rd.keys, ke)

                                insideBracket = false

                        default:

                                // checking if not a number, 0-9 is 48-57 in byte, see for yourself fmt.Println('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')

                                if insideBracket && (k[i] > 57 || k[i] < 48) {

                                        isNum = false

                                }

                if insideBracket {

                        log.Panicf(errMissingEndBracket, k)

                }

func (d *decoder) traverseStruct(v reflect.Value, typ reflect.Type, namespace []byte) (set bool) {

        l := len(namespace)

        first := l == 0

        // anonymous structs will still work for caching as the whole definition is stored

        // including tags

        s, ok := d.d.structCache.Get(typ)

        if !ok {

                s = d.d.structCache.parseStruct(d.d.mode, v, typ, d.d.tagName)

        }

        for _, f := range s.fields {

                namespace = namespace[:l]

                if f.isAnonymous {

                        if d.setFieldByType(v.Field(f.idx), namespace, 0) {

                                set = true

                        }

                if first {

                        namespace = append(namespace, f.name...)

                } else {

                        namespace = append(namespace, d.d.namespacePrefix...)

                        namespace = append(namespace, f.name...)

                        namespace = append(namespace, d.d.namespaceSuffix...)

                }

                if d.setFieldByType(v.Field(f.idx), namespace, 0) {

                        set = true

                }

        return

func (d *decoder) setFieldByType(current reflect.Value, namespace []byte, idx int) (set bool) {

        var err error

        v, kind := ExtractType(current)

        arr, ok := d.values[string(namespace)]

        if d.d.customTypeFuncs != nil {

                if ok {

                        if cf, ok := d.d.customTypeFuncs[v.Type()]; ok {

                                val, err := cf(arr[idx:])

                                if err != nil {

                                        d.setError(namespace, err)

                                        return

                                }

                                v.Set(reflect.ValueOf(val))

                                set = true

                                return

        switch kind {

        case reflect.Interface:

                if !ok || idx == len(arr) {

                        return

                }

                v.Set(reflect.ValueOf(arr[idx]))

                set = true

        case reflect.Ptr:

                newVal := reflect.New(v.Type().Elem())

                if set = d.setFieldByType(newVal.Elem(), namespace, idx); set {

                        v.Set(newVal)

                }

        case reflect.String:

                if !ok || idx == len(arr) {

                        return

                }

                v.SetString(arr[idx])

                set = true

        case reflect.Uint, reflect.Uint64:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var u64 uint64

                if u64, err = strconv.ParseUint(arr[idx], 10, 64); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetUint(u64)

                set = true

        case reflect.Uint8:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var u64 uint64

                if u64, err = strconv.ParseUint(arr[idx], 10, 8); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetUint(u64)

                set = true

        case reflect.Uint16:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var u64 uint64

                if u64, err = strconv.ParseUint(arr[idx], 10, 16); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetUint(u64)

                set = true

        case reflect.Uint32:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var u64 uint64

                if u64, err = strconv.ParseUint(arr[idx], 10, 32); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetUint(u64)

                set = true

        case reflect.Int, reflect.Int64:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var i64 int64

                if i64, err = strconv.ParseInt(arr[idx], 10, 64); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetInt(i64)

                set = true

        case reflect.Int8:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var i64 int64

                if i64, err = strconv.ParseInt(arr[idx], 10, 8); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetInt(i64)

                set = true

        case reflect.Int16:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var i64 int64

                if i64, err = strconv.ParseInt(arr[idx], 10, 16); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetInt(i64)

                set = true

        case reflect.Int32:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var i64 int64

                if i64, err = strconv.ParseInt(arr[idx], 10, 32); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetInt(i64)

                set = true

        case reflect.Float32:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var f float64

                if f, err = strconv.ParseFloat(arr[idx], 32); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Float Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetFloat(f)

                set = true

        case reflect.Float64:

                if !ok || idx == len(arr) || len(arr[idx]) == 0 {

                        return

                }

                var f float64

                if f, err = strconv.ParseFloat(arr[idx], 64); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Float Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetFloat(f)

                set = true

        case reflect.Bool:

                if !ok || idx == len(arr) {

                        return

                }

                var b bool

                if b, err = parseBool(arr[idx]); err != nil {

                        d.setError(namespace, fmt.Errorf("Invalid Boolean Value '%s' Type '%v' Namespace '%s'", arr[idx], v.Type(), string(namespace)))

                        return

                }

                v.SetBool(b)

                set = true

        case reflect.Slice:

                d.parseMapData()

                // slice elements could be mixed eg. number and non-numbers Value[0]=[]string{"10"} and Value=[]string{"10","20"}

                if ok && len(arr) > 0 {

                        var varr reflect.Value

                        var ol int

                        l := len(arr)

                        if v.IsNil() {

                                varr = reflect.MakeSlice(v.Type(), len(arr), len(arr))

                        } else {

                                ol = v.Len()

                                l += ol

                                if v.Cap() <= l {

                                        varr = reflect.MakeSlice(v.Type(), l, l)

                                } else {

                                        // preserve predefined capacity, possibly for reuse after decoding

                                        varr = reflect.MakeSlice(v.Type(), l, v.Cap())

                                }

                                reflect.Copy(varr, v)

                        for i := ol; i < l; i++ {

                                newVal := reflect.New(v.Type().Elem()).Elem()

                                if d.setFieldByType(newVal, namespace, i-ol) {

                                        set = true

                                        varr.Index(i).Set(newVal)

                                }

                        v.Set(varr)

                if rd := d.findAlias(string(namespace)); rd != nil {

                        var varr reflect.Value

                        var kv key

                        sl := rd.sliceLen + 1

                        // checking below for maxArraySize, but if array exists and already

                        // has sufficient capacity allocated then we do not check as the code

                        // obviously allows a capacity greater than the maxArraySize.

                        if v.IsNil() {

                                if sl > d.d.maxArraySize {

                                        d.setError(namespace, fmt.Errorf(errArraySize, sl, d.d.maxArraySize))

                                        return

                                }

                                varr = reflect.MakeSlice(v.Type(), sl, sl)

                        } else if v.Len() < sl {

                                if v.Cap() <= sl {

                                        if sl > d.d.maxArraySize {

                                                d.setError(namespace, fmt.Errorf(errArraySize, sl, d.d.maxArraySize))

                                                return

                                        }

                                        varr = reflect.MakeSlice(v.Type(), sl, sl)

                                } else {

                                        varr = reflect.MakeSlice(v.Type(), sl, v.Cap())

                                }

                                reflect.Copy(varr, v)

                        } else {

                                varr = v

                        }

                        for i := 0; i < len(rd.keys); i++ {

                                kv = rd.keys[i]

                                newVal := reflect.New(varr.Type().Elem()).Elem()

                                if kv.ivalue == -1 {

                                        d.setError(namespace, fmt.Errorf("invalid slice index '%s'", kv.value))

                                        continue

                                if d.setFieldByType(newVal, append(namespace, kv.searchValue...), 0) {

                                        set = true

                                        varr.Index(kv.ivalue).Set(newVal)

                                }

                        if !set {

                                return

                        }

                        v.Set(varr)

        case reflect.Array:

                d.parseMapData()

                // array elements could be mixed eg. number and non-numbers Value[0]=[]string{"10"} and Value=[]string{"10","20"}

                if ok && len(arr) > 0 {

                        var varr reflect.Value

                        l := len(arr)

                        overCapacity := v.Len() < l

                        if overCapacity {

                                // more values than array capacity, ignore values over capacity as it's possible some would just want

                                // to grab the first x number of elements; in the future strict mode logic should return an error

                                fmt.Println("warning number of post form array values is larger than array capacity, ignoring overflow values")

                        }

                        varr = reflect.Indirect(reflect.New(reflect.ArrayOf(v.Len(), v.Type().Elem())))

                        reflect.Copy(varr, v)

                        if v.Len() < len(arr) {

                                l = v.Len()

                        }

                        for i := 0; i < l; i++ {

                                newVal := reflect.New(v.Type().Elem()).Elem()

                                if d.setFieldByType(newVal, namespace, i) {

                                        set = true

                                        varr.Index(i).Set(newVal)

                                }

                        v.Set(varr)

                if rd := d.findAlias(string(namespace)); rd != nil {

                        var varr reflect.Value

                        var kv key

                        overCapacity := rd.sliceLen >= v.Len()

                        if overCapacity {

                                // more values than array capacity, ignore values over capacity as it's possible some would just want

                                // to grab the first x number of elements; in the future strict mode logic should return an error

                                fmt.Println("warning number of post form array values is larger than array capacity, ignoring overflow values")

                        }

                        varr = reflect.Indirect(reflect.New(reflect.ArrayOf(v.Len(), v.Type().Elem())))

                        reflect.Copy(varr, v)

                        for i := 0; i < len(rd.keys); i++ {

                                kv = rd.keys[i]

                                if kv.ivalue >= v.Len() {

                                        continue

                                newVal := reflect.New(varr.Type().Elem()).Elem()

                                if kv.ivalue == -1 {

                                        d.setError(namespace, fmt.Errorf("invalid array index '%s'", kv.value))

                                        continue

                                if d.setFieldByType(newVal, append(namespace, kv.searchValue...), 0) {

                                        set = true

                                        varr.Index(kv.ivalue).Set(newVal)

                                }

                        if !set {

                                return

                        }

                        v.Set(varr)

        case reflect.Map:

                var rd *recursiveData

                d.parseMapData()

                // no natural map support so skip directly to dm lookup

                if rd = d.findAlias(string(namespace)); rd == nil {

                        return

                }

                var existing bool

                var kv key

                var mp reflect.Value

                var mk reflect.Value

                typ := v.Type()

                if v.IsNil() {

                        mp = reflect.MakeMap(typ)

                } else {

                        existing = true

                        mp = v

                }

                for i := 0; i < len(rd.keys); i++ {

                        newVal := reflect.New(typ.Elem()).Elem()

                        mk = reflect.New(typ.Key()).Elem()

                        kv = rd.keys[i]

                        if err := d.getMapKey(kv.value, mk, namespace); err != nil {

                                d.setError(namespace, err)

                                continue

                        if d.setFieldByType(newVal, append(namespace, kv.searchValue...), 0) {

                                set = true

                                mp.SetMapIndex(mk, newVal)

                        }

                if !set || existing {

                        return

                }

                v.Set(mp)

        case reflect.Struct:

                typ := v.Type()

                // if we get here then no custom time function declared so use RFC3339 by default

                if typ == timeType {

                        if !ok || len(arr[idx]) == 0 {

                                return

                        }

                        t, err := time.Parse(time.RFC3339, arr[idx])

                        if err != nil {

                                d.setError(namespace, err)

                        }

                        v.Set(reflect.ValueOf(t))

                        set = true

                        return

                d.parseMapData()

                // we must be recursing infinitly...but that's ok we caught it on the very first overun.

                if len(namespace) > d.maxKeyLen {

                        return

                }

                set = d.traverseStruct(v, typ, namespace)

        return

func (d *decoder) getMapKey(key string, current reflect.Value, namespace []byte) (err error) {

        v, kind := ExtractType(current)

        if d.d.customTypeFuncs != nil {

                if cf, ok := d.d.customTypeFuncs[v.Type()]; ok {

                        val, er := cf([]string{key})

                        if er != nil {

                                err = er

                                return

                        }

                        v.Set(reflect.ValueOf(val))

                        return

        switch kind {

        case reflect.Interface:

                // If interface would have been set on the struct before decoding,

                // say to a struct value we would not get here but kind would be struct.

                v.Set(reflect.ValueOf(key))

                return

        case reflect.Ptr:

                newVal := reflect.New(v.Type().Elem())

                if err = d.getMapKey(key, newVal.Elem(), namespace); err == nil {

                        v.Set(newVal)

                }

        case reflect.String:

                v.SetString(key)

        case reflect.Uint, reflect.Uint64:

                u64, e := strconv.ParseUint(key, 10, 64)

                if e != nil {

                        err = fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetUint(u64)

        case reflect.Uint8:

                u64, e := strconv.ParseUint(key, 10, 8)

                if e != nil {

                        err = fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetUint(u64)

        case reflect.Uint16:

                u64, e := strconv.ParseUint(key, 10, 16)

                if e != nil {

                        err = fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetUint(u64)

        case reflect.Uint32:

                u64, e := strconv.ParseUint(key, 10, 32)

                if e != nil {

                        err = fmt.Errorf("Invalid Unsigned Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetUint(u64)

        case reflect.Int, reflect.Int64:

                i64, e := strconv.ParseInt(key, 10, 64)

                if e != nil {

                        err = fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetInt(i64)

        case reflect.Int8:

                i64, e := strconv.ParseInt(key, 10, 8)

                if e != nil {

                        err = fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetInt(i64)

        case reflect.Int16:

                i64, e := strconv.ParseInt(key, 10, 16)

                if e != nil {

                        err = fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetInt(i64)

        case reflect.Int32:

                i64, e := strconv.ParseInt(key, 10, 32)

                if e != nil {

                        err = fmt.Errorf("Invalid Integer Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetInt(i64)

        case reflect.Float32:

                f, e := strconv.ParseFloat(key, 32)

                if e != nil {

                        err = fmt.Errorf("Invalid Float Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetFloat(f)

        case reflect.Float64:

                f, e := strconv.ParseFloat(key, 64)

                if e != nil {

                        err = fmt.Errorf("Invalid Float Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetFloat(f)

        case reflect.Bool:

                b, e := parseBool(key)

                if e != nil {

                        err = fmt.Errorf("Invalid Boolean Value '%s' Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

                        return

                }

                v.SetBool(b)

        default:

                err = fmt.Errorf("Unsupported Map Key '%s', Type '%v' Namespace '%s'", key, v.Type(), string(namespace))

        return