feat:增加mapstructure -> kmapstructure

Author: zhangyu

utils/kmapstructure/decode_hooks.go

@@ -0,0 +1,279 @@
+package kmapstructure
+
+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
+  }
+}