gtsocial-umbx

decode_hooks.go (6908B)

---

 package mapstructure
 
 import (
 	"encoding"
 	"errors"
 	"fmt"
 	"net"
 	"reflect"
 	"strconv"
 	"strings"
 	"time"
 )
 
 // typedDecodeHook takes a raw DecodeHookFunc (an interface{}) and turns
 // it into the proper DecodeHookFunc type, such as DecodeHookFuncType.
 func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
 	// Create variables here so we can reference them with the reflect pkg
 	var f1 DecodeHookFuncType
 	var f2 DecodeHookFuncKind
 	var f3 DecodeHookFuncValue
 
 	// Fill in the variables into this interface and the rest is done
 	// automatically using the reflect package.
 	potential := []interface{}{f1, f2, f3}
 
 	v := reflect.ValueOf(h)
 	vt := v.Type()
 	for _, raw := range potential {
 		pt := reflect.ValueOf(raw).Type()
 		if vt.ConvertibleTo(pt) {
 			return v.Convert(pt).Interface()
 		}
 	}
 
 	return nil
 }
 
 // DecodeHookExec executes the given decode hook. This should be used
 // since it'll naturally degrade to the older backwards compatible DecodeHookFunc
 // that took reflect.Kind instead of reflect.Type.
 func DecodeHookExec(
 	raw DecodeHookFunc,
 	from reflect.Value, to reflect.Value) (interface{}, error) {
 
 	switch f := typedDecodeHook(raw).(type) {
 	case DecodeHookFuncType:
 		return f(from.Type(), to.Type(), from.Interface())
 	case DecodeHookFuncKind:
 		return f(from.Kind(), to.Kind(), from.Interface())
 	case DecodeHookFuncValue:
 		return f(from, to)
 	default:
 		return nil, errors.New("invalid decode hook signature")
 	}
 }
 
 // ComposeDecodeHookFunc creates a single DecodeHookFunc that
 // automatically composes multiple DecodeHookFuncs.
 //
 // The composed funcs are called in order, with the result of the
 // previous transformation.
 func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
 	return func(f reflect.Value, t reflect.Value) (interface{}, error) {
 		var err error
 		data := f.Interface()
 
 		newFrom := f
 		for _, f1 := range fs {
 			data, err = DecodeHookExec(f1, newFrom, t)
 			if err != nil {
 				return nil, err
 			}
 			newFrom = reflect.ValueOf(data)
 		}
 
 		return data, nil
 	}
 }
 
 // OrComposeDecodeHookFunc executes all input hook functions until one of them returns no error. In that case its value is returned.
 // If all hooks return an error, OrComposeDecodeHookFunc returns an error concatenating all error messages.
 func OrComposeDecodeHookFunc(ff ...DecodeHookFunc) DecodeHookFunc {
 	return func(a, b reflect.Value) (interface{}, error) {
 		var allErrs string
 		var out interface{}
 		var err error
 
 		for _, f := range ff {
 			out, err = DecodeHookExec(f, a, b)
 			if err != nil {
 				allErrs += err.Error() + "\n"
 				continue
 			}
 
 			return out, nil
 		}
 
 		return nil, errors.New(allErrs)
 	}
 }
 
 // StringToSliceHookFunc returns a DecodeHookFunc that converts
 // string to []string by splitting on the given sep.
 func StringToSliceHookFunc(sep string) DecodeHookFunc {
 	return func(
 		f reflect.Kind,
 		t reflect.Kind,
 		data interface{}) (interface{}, error) {
 		if f != reflect.String || t != reflect.Slice {
 			return data, nil
 		}
 
 		raw := data.(string)
 		if raw == "" {
 			return []string{}, nil
 		}
 
 		return strings.Split(raw, sep), nil
 	}
 }
 
 // StringToTimeDurationHookFunc returns a DecodeHookFunc that converts
 // strings to time.Duration.
 func StringToTimeDurationHookFunc() DecodeHookFunc {
 	return func(
 		f reflect.Type,
 		t reflect.Type,
 		data interface{}) (interface{}, error) {
 		if f.Kind() != reflect.String {
 			return data, nil
 		}
 		if t != reflect.TypeOf(time.Duration(5)) {
 			return data, nil
 		}
 
 		// Convert it by parsing
 		return time.ParseDuration(data.(string))
 	}
 }
 
 // StringToIPHookFunc returns a DecodeHookFunc that converts
 // strings to net.IP
 func StringToIPHookFunc() DecodeHookFunc {
 	return func(
 		f reflect.Type,
 		t reflect.Type,
 		data interface{}) (interface{}, error) {
 		if f.Kind() != reflect.String {
 			return data, nil
 		}
 		if t != reflect.TypeOf(net.IP{}) {
 			return data, nil
 		}
 
 		// Convert it by parsing
 		ip := net.ParseIP(data.(string))
 		if ip == nil {
 			return net.IP{}, fmt.Errorf("failed parsing ip %v", data)
 		}
 
 		return ip, nil
 	}
 }
 
 // StringToIPNetHookFunc returns a DecodeHookFunc that converts
 // strings to net.IPNet
 func StringToIPNetHookFunc() DecodeHookFunc {
 	return func(
 		f reflect.Type,
 		t reflect.Type,
 		data interface{}) (interface{}, error) {
 		if f.Kind() != reflect.String {
 			return data, nil
 		}
 		if t != reflect.TypeOf(net.IPNet{}) {
 			return data, nil
 		}
 
 		// Convert it by parsing
 		_, net, err := net.ParseCIDR(data.(string))
 		return net, err
 	}
 }
 
 // StringToTimeHookFunc returns a DecodeHookFunc that converts
 // strings to time.Time.
 func StringToTimeHookFunc(layout string) DecodeHookFunc {
 	return func(
 		f reflect.Type,
 		t reflect.Type,
 		data interface{}) (interface{}, error) {
 		if f.Kind() != reflect.String {
 			return data, nil
 		}
 		if t != reflect.TypeOf(time.Time{}) {
 			return data, nil
 		}
 
 		// Convert it by parsing
 		return time.Parse(layout, data.(string))
 	}
 }
 
 // WeaklyTypedHook is a DecodeHookFunc which adds support for weak typing to
 // the decoder.
 //
 // Note that this is significantly different from the WeaklyTypedInput option
 // of the DecoderConfig.
 func WeaklyTypedHook(
 	f reflect.Kind,
 	t reflect.Kind,
 	data interface{}) (interface{}, error) {
 	dataVal := reflect.ValueOf(data)
 	switch t {
 	case reflect.String:
 		switch f {
 		case reflect.Bool:
 			if dataVal.Bool() {
 				return "1", nil
 			}
 			return "0", nil
 		case reflect.Float32:
 			return strconv.FormatFloat(dataVal.Float(), 'f', -1, 64), nil
 		case reflect.Int:
 			return strconv.FormatInt(dataVal.Int(), 10), nil
 		case reflect.Slice:
 			dataType := dataVal.Type()
 			elemKind := dataType.Elem().Kind()
 			if elemKind == reflect.Uint8 {
 				return string(dataVal.Interface().([]uint8)), nil
 			}
 		case reflect.Uint:
 			return strconv.FormatUint(dataVal.Uint(), 10), nil
 		}
 	}
 
 	return data, nil
 }
 
 func RecursiveStructToMapHookFunc() DecodeHookFunc {
 	return func(f reflect.Value, t reflect.Value) (interface{}, error) {
 		if f.Kind() != reflect.Struct {
 			return f.Interface(), nil
 		}
 
 		var i interface{} = struct{}{}
 		if t.Type() != reflect.TypeOf(&i).Elem() {
 			return f.Interface(), nil
 		}
 
 		m := make(map[string]interface{})
 		t.Set(reflect.ValueOf(m))
 
 		return f.Interface(), nil
 	}
 }
 
 // TextUnmarshallerHookFunc returns a DecodeHookFunc that applies
 // strings to the UnmarshalText function, when the target type
 // implements the encoding.TextUnmarshaler interface
 func TextUnmarshallerHookFunc() DecodeHookFuncType {
 	return func(
 		f reflect.Type,
 		t reflect.Type,
 		data interface{}) (interface{}, error) {
 		if f.Kind() != reflect.String {
 			return data, nil
 		}
 		result := reflect.New(t).Interface()
 		unmarshaller, ok := result.(encoding.TextUnmarshaler)
 		if !ok {
 			return data, nil
 		}
 		if err := unmarshaller.UnmarshalText([]byte(data.(string))); err != nil {
 			return nil, err
 		}
 		return result, nil
 	}
 }