conversion负责转换两个obj，挨个遍历其中一个obj的属性，找到key或者tag一样的另一边的属性并进行赋值。若有用户注册的转换函数，则调用用户注册的转换函数。

1、ConversionFuncs

  1. type ConversionFuncs struct {
  2.     untyped map[typePair]ConversionFunc
  3. }
  5. // 注册一个转换函数
  6. // typePair里面的src和dest为指针
  7. func (c ConversionFuncs) AddUntyped(a, b interface{}, fn ConversionFunc) error {
  8.     tA, tB := reflect.TypeOf(a), reflect.TypeOf(b)
  9.     if tA.Kind() != reflect.Ptr {
  10.         return fmt.Errorf("the type %T must be a pointer to register as an untyped conversion", a)
  11.     }
  12.     if tB.Kind() != reflect.Ptr {
  13.         return fmt.Errorf("the type %T must be a pointer to register as an untyped conversion", b)
  14.     }
  15.     c.untyped[typePair{tA, tB}] = fn
  16.     return nil
  17. }
  19. // 合并
  20. func (c ConversionFuncs) Merge(other ConversionFuncs) ConversionFuncs {
  21.     merged := NewConversionFuncs()
  22.     for k, v := range c.untyped {
  23.         merged.untyped[k] = v
  24.     }
  25.     for k, v := range other.untyped {
  26.         merged.untyped[k] = v
  27.     }
  28.     return merged
  29. }

2、Scope

  1. type Scope interface {
  2.     Convert(src, dest interface{}, flags FieldMatchingFlags) error
  3.     // SrcTag和DestTag返回的是当前正在比较的两个属性
  4.     // 供转换函数进行更进一步的转换
  5.     SrcTag() reflect.StructTag
  6.     DestTag() reflect.StructTag
  7.     Flags() FieldMatchingFlags
  8.     Meta() *Meta
  9. }
  11. // 用来给转换函数传递额外的信息，被封装在scope里面
  12. type Meta struct {
  13.     KeyNameMapping FieldMappingFunc
  14.     Context interface{}
  15. }
  17. type scope struct {
  18.     converter *Converter
  19.     meta      *Meta
  20.     flags     FieldMatchingFlags
  22.     srcStack  scopeStack
  23.     destStack scopeStack
  24. }
  26. func (s *scope) Convert(src, dest interface{}, flags FieldMatchingFlags) error {
  27.     return s.converter.Convert(src, dest, flags, s.meta)
  28. }
  30. // 返回最新找到的属性的tag
  31. func (s *scope) SrcTag() reflect.StructTag {
  32.     return s.srcStack.top().tag
  33. }
  35. // 返回最新找到的属性的tag
  36. func (s *scope) DestTag() reflect.StructTag {
  37.     return s.destStack.top().tag
  38. }
  40. func (s *scope) Flags() FieldMatchingFlags {
  41.     return s.flags
  42. }
  44. // Meta returns the meta object that was originally passed to Convert.
  45. func (s *scope) Meta() *Meta {
  46.     return s.meta
  47. }
  49. func (s *scope) setIndices(src, dest int) {
  50.     s.srcStack.top().key = fmt.Sprintf("[%v]", src)
  51.     s.destStack.top().key = fmt.Sprintf("[%v]", dest)
  52. }
  54. func (s *scope) setKeys(src, dest interface{}) {
  55.     s.srcStack.top().key = fmt.Sprintf(`["%v"]`, src)
  56.     s.destStack.top().key = fmt.Sprintf(`["%v"]`, dest)
  57. }
  59. func (s *scope) describe() (src, dest string) {
  60.     return s.srcStack.describe(), s.destStack.describe()
  61. }
  63. func (s *scope) errorf(message string, args ...interface{}) error {
  64.     srcPath, destPath := s.describe()
  65.     where := fmt.Sprintf("converting %v to %v: ", srcPath, destPath)
  66.     return fmt.Errorf(where+message, args...)
  67. }
  69. type scopeStackElem struct {
  70.     tag   reflect.StructTag
  71.     value reflect.Value
  72.     key   string
  73. }
  75. type scopeStack []scopeStackElem
  77. func (s *scopeStack) pop() {
  78.     n := len(*s)
  79.     *s = (*s)[:n-1]
  80. }
  82. func (s *scopeStack) push(e scopeStackElem) {
  83.     *s = append(*s, e)
  84. }
  86. func (s *scopeStack) top() *scopeStackElem {
  87.     return &(*s)[len(*s)-1]
  88. }
  90. func (s scopeStack) describe() string {
  91.     desc := ""
  92.     if len(s) > 1 {
  93.         desc = "(" + s[1].value.Type().String() + ")"
  94.     }
  95.     for i, v := range s {
  96.         if i < 2 {
  97.             // First layer on stack is not real; second is handled specially above.
  98.             continue
  99.         }
  100.         if v.key == "" {
  101.             desc += fmt.Sprintf(".%v", v.value.Type())
  102.         } else {
  103.             desc += fmt.Sprintf(".%v", v.key)
  104.         }
  105.     }
  106.     return desc
  107. }

3、Converter

  1. type Converter struct {
  2.     // 注册的转换函数
  3.     // generatedConversionFuncs一般为脚手架生成的转换函数
  4.     // 用户自定义注入到conversionFuncs
  5.     // 且conversionFuncs的优先级比generatedConversionFuncs高
  6.     conversionFuncs          ConversionFuncs
  7.     generatedConversionFuncs ConversionFuncs
  9.     // 忽略掉一些类型的转换
  10.     ignoredConversions        map[typePair]struct{}
  11.     ignoredUntypedConversions map[typePair]struct{}
  13.     // 实际代码里面两个变量没有作用
  14.     // src -> dest
  15.     structFieldDests map[typeNamePair][]typeNamePair
  16.     // dest -> src
  17.     structFieldSources map[typeNamePair][]typeNamePair
  19.     // field mapping函数
  20.     // 默认注册了map[string][]string{}/url.Values{}
  21.     // 对应的field mapping函数为JSONKeyMapper
  22.     // 根据结构体tag匹配map的key
  23.     inputFieldMappingFuncs map[reflect.Type]FieldMappingFunc
  25.     // obj默认匹配flag，包含以下四种
  26.     // DestFromSource、SourceToDest、IgnoreMissingFields、AllowDifferentFieldTypeNames
  27.     inputDefaultFlags map[reflect.Type]FieldMatchingFlags
  29.     // 日志
  30.     Debug DebugLogger
  32.     // 类型名称函数
  33.     nameFunc func(t reflect.Type) string
  34. }
  36. // 初始化函数并注册切片转换函数
  37. func NewConverter(nameFn NameFunc) *Converter {
  38.     c := &Converter{
  39.         conversionFuncs:           NewConversionFuncs(),
  40.         generatedConversionFuncs:  NewConversionFuncs(),
  41.         ignoredConversions:        make(map[typePair]struct{}),
  42.         ignoredUntypedConversions: make(map[typePair]struct{}),
  43.         nameFunc:                  nameFn,
  44.         structFieldDests:          make(map[typeNamePair][]typeNamePair),
  45.         structFieldSources:        make(map[typeNamePair][]typeNamePair),
  47.         inputFieldMappingFuncs: make(map[reflect.Type]FieldMappingFunc),
  48.         inputDefaultFlags:      make(map[reflect.Type]FieldMatchingFlags),
  49.     }
  50.     c.RegisterUntypedConversionFunc(
  51.         (*[]byte)(nil), (*[]byte)(nil),
  52.         func(a, b interface{}, s Scope) error {
  53.             return Convert_Slice_byte_To_Slice_byte(a.(*[]byte), b.(*[]byte), s)
  54.         },
  55.     )
  56.     return c
  57. }
  59. // src/dest必须为指针
  60. // meta是用来给转换函数传递信息的，被用来封装在scope中
  61. // Scheme调用Scheme.Convert之前会调用DefaultMeta获取flags和meta并传入Converter.Convert
  62. func (c *Converter) Convert(src, dest interface{}, flags FieldMatchingFlags, meta *Meta) error {
  63.     return c.doConversion(src, dest, flags, meta, c.convert)
  64. }
  66. // 开启转换
  67. // 首先检查是否注册了转换函数
  68. // 否则用默认的转换函数进行转换
  69. func (c *Converter) doConversion(src, dest interface{}, flags FieldMatchingFlags, meta *Meta, f conversionFunc) error {
  70.     pair := typePair{reflect.TypeOf(src), reflect.TypeOf(dest)}
  71.     scope := &scope{
  72.         converter: c,
  73.         flags:     flags,
  74.         meta:      meta,
  75.     }
  77.     // 是否被忽略
  78.     if _, ok := c.ignoredUntypedConversions[pair]; ok {
  79.         return nil
  80.     }
  82.     // 优先检查用户自定义转换函数
  83.     if fn, ok := c.conversionFuncs.untyped[pair]; ok {
  84.         return fn(src, dest, scope)
  85.     }
  87.     // 检查是否有用脚手架生成的转换函数
  88.     if fn, ok := c.generatedConversionFuncs.untyped[pair]; ok {
  89.         return fn(src, dest, scope)
  90.     }
  92.     // 确保obj为ptr且不为nil并返回obj的Value对象
  93.     dv, err := EnforcePtr(dest)
  94.     if err != nil {
  95.         return err
  96.     }
  98.     // 对于dest对象，必须可以取址和设置(要给dest赋值，必须满足这两个条件，src则不需要)
  99.     if !dv.CanAddr() && !dv.CanSet() {
  100.         return fmt.Errorf("can't write to dest")
  101.     }
  102.     sv, err := EnforcePtr(src)
  103.     if err != nil {
  104.         return err
  105.     }
  107.     // 保留空的scopeStackElem，包装struct tag getters不会失败
  108.     // Leave something on the stack, so that calls to struct tag getters never fail.
  109.     scope.srcStack.push(scopeStackElem{})
  110.     scope.destStack.push(scopeStackElem{})
  111.     return f(sv, dv, scope)
  112. }
  114. // 未匹配到注册函数，则进入默认转换函数
  115. // 此处的value已经是struct本身了，不需要处理Ptr
  116. func (c *Converter) convert(sv, dv reflect.Value, scope *scope) error {
  117.     dt, st := dv.Type(), sv.Type()
  118.     pair := typePair{st, dt}
  120.     // 是否被忽略
  121.     if _, ok := c.ignoredConversions[pair]; ok {
  122.         return nil
  123.     }
  125.     // 开始转换
  126.     // 由于convert可能被递归调用，因此需要先判断是否有符合条件的转换函数
  127.     // 这里需要转换为指针的type
  128.     pair = typePair{reflect.PtrTo(sv.Type()), reflect.PtrTo(dv.Type())}
  129.     if f, ok := c.conversionFuncs.untyped[pair]; ok {
  130.         return c.callUntyped(sv, dv, f, scope)
  131.     }
  132.     if f, ok := c.generatedConversionFuncs.untyped[pair]; ok {
  133.         return c.callUntyped(sv, dv, f, scope)
  134.     }
  136.     // 检查dv是否可以被设置
  137.     if !dv.CanSet() {
  138.         return scope.errorf("Cannot set dest. (Tried to deep copy something with unexported fields?)")
  139.     }
  141.     // 若未设置AllowDifferentFieldTypeNames，但是field名称不一样，则直接抛异常
  142.     if !scope.flags.IsSet(AllowDifferentFieldTypeNames) && c.nameFunc(dt) != c.nameFunc(st) {
  143.         return scope.errorf(
  144.             "type names don't match (%v, %v), and no conversion 'func (%v, %v) error' registered.",
  145.             c.nameFunc(st), c.nameFunc(dt), st, dt)
  146.     }
  148.     // 检查src对象是否为简单类型
  149.     switch st.Kind() {
  150.     case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct:
  151.     default:
  152.         // 若为简单类型直接，则
  153.         // 若二者类型一样，直接赋值返回
  154.         // 否则检查是否可以st -> dt，可以直接赋值返回
  155.         if st.AssignableTo(dt) {
  156.             dv.Set(sv)
  157.             return nil
  158.         }
  159.         if st.ConvertibleTo(dt) {
  160.             dv.Set(sv.Convert(dt))
  161.             return nil
  162.         }
  163.     }
  165.     scope.srcStack.push(scopeStackElem{value: sv})
  166.     scope.destStack.push(scopeStackElem{value: dv})
  167.     defer scope.srcStack.pop()
  168.     defer scope.destStack.pop()
  170.     // 检查目标对象的类型
  171.     switch dv.Kind() {
  172.         // 若为结构体类型，直接调用convertKV进行比较
  173.         // 此处支持struct -> struct, map -> struct
  174.     case reflect.Struct:
  175.         return c.convertKV(toKVValue(sv), toKVValue(dv), scope)
  176.     case reflect.Slice:
  177.         // 若为切片，则
  178.         // 若sv为空，则赋值返回
  179.         // 此处支持map/chan/slice/string/array -> slice
  180.         if sv.IsNil() {
  181.             dv.Set(reflect.Zero(dt))
  182.             return nil
  183.         }
  184.         // 否则对dv进行挨个赋值
  185.         dv.Set(reflect.MakeSlice(dt, sv.Len(), sv.Cap()))
  186.         for i := 0; i < sv.Len(); i++ {
  187.             scope.setIndices(i, i)
  188.             if err := c.convert(sv.Index(i), dv.Index(i), scope); err != nil {
  189.                 return err
  190.             }
  191.         }
  192.     case reflect.Ptr:
  193.         if sv.IsNil() {
  194.             dv.Set(reflect.Zero(dt))
  195.             return nil
  196.         }
  197.         dv.Set(reflect.New(dt.Elem()))
  198.         switch st.Kind() {
  199.         case reflect.Ptr, reflect.Interface:
  200.             return c.convert(sv.Elem(), dv.Elem(), scope)
  201.         default:
  202.             return c.convert(sv, dv.Elem(), scope)
  203.         }
  204.     case reflect.Map:
  205.         if sv.IsNil() {
  206.             dv.Set(reflect.Zero(dt))
  207.             return nil
  208.         }
  209.         // 此处支持map -> map
  210.         dv.Set(reflect.MakeMap(dt))
  211.         for _, sk := range sv.MapKeys() {
  212.             dk := reflect.New(dt.Key()).Elem()
  213.             if err := c.convert(sk, dk, scope); err != nil {
  214.                 return err
  215.             }
  216.             dkv := reflect.New(dt.Elem()).Elem()
  217.             scope.setKeys(sk.Interface(), dk.Interface())
  218.             if err := c.convert(sv.MapIndex(sk), dkv, scope); err != nil {
  219.                 return err
  220.             }
  221.             dv.SetMapIndex(dk, dkv)
  222.         }
  223.     case reflect.Interface:
  224.         if sv.IsNil() {
  225.             dv.Set(reflect.Zero(dt))
  226.             return nil
  227.         }
  228.         tmpdv := reflect.New(sv.Elem().Type()).Elem()
  229.         if err := c.convert(sv.Elem(), tmpdv, scope); err != nil {
  230.             return err
  231.         }
  232.         dv.Set(reflect.ValueOf(tmpdv.Interface()))
  233.         return nil
  234.     default:
  235.         return scope.errorf("couldn't copy '%v' into '%v'; didn't understand types", st, dt)
  236.     }
  237.     return nil
  238. }
  240. func (c *Converter) convertKV(skv, dkv kvValue, scope *scope) error {
  241.     if skv == nil || dkv == nil {
  242.         return fmt.Errorf("unable to convert %#v to %#v", skv, dkv)
  243.     }
  245.     // 默认遍历dest，若设置了SourceToDest则遍历src
  246.     lister := dkv
  247.     if scope.flags.IsSet(SourceToDest) {
  248.         lister = skv
  249.     }
  251.     // 检查是否设置了mapping函数
  252.     var mapping FieldMappingFunc
  253.     if scope.meta != nil && scope.meta.KeyNameMapping != nil {
  254.         mapping = scope.meta.KeyNameMapping
  255.     }
  257.     // eg.
  258.     // type TestA struct {
  259.     //      A string `test:"a"`
  260.     //      B string `test:"b"`
  261.     // }
  262.     // type TestB struct {
  263.     //      A string `test:"b"`
  264.     //      B string `test:"a"`
  265.     // }
  266.     // 假设此处遍历TestA
  267.     // key为A
  268.     for _, key := range lister.keys() {
  269.         // found均为false，忽略即可
  270.         if found, err := c.checkField(key, skv, dkv, scope); found {
  271.             if err != nil {
  272.                 return err
  273.             }
  274.             continue
  275.         }
  277.         // 获取key对应的tag
  278.         // stag/dtag分别为a，b
  279.         stag := skv.tagOf(key)
  280.         dtag := dkv.tagOf(key)
  282.         // skey为A
  283.         // dkey为B
  284.         skey := key
  285.         dkey := key
  286.         if mapping != nil {
  287.             // 若配置了mapping函数,一般是针对map -> struct，map -> map，struct -> struct的映射
  288.             // x := map[string][]string{
  289.             //         "Foo":  {"bar"},
  290.             //         "test": {"baz"},
  291.             // }
  292.             // type A struct {
  293.             //     Foo   string `json:"test"`
  294.             // }
  295.             // func JSONKeyMapper(key string, sourceTag, destTag reflect.StructTag) (string, string) {
  296.             //     if s := destTag.Get("json"); len(s) > 0 {
  297.             //         return strings.SplitN(s, ",", 2)[0], key
  298.             //     }
  299.             //     if s := sourceTag.Get("json"); len(s) > 0 {
  300.             //         return key, strings.SplitN(s, ",", 2)[0]
  301.             //     }
  302.             //     return key, key
  303.             // }
  304.             // 1、遍历dest。则key为Foo。stag/dtag分别为""/test。因此mapping之后
  305.             // skey/dkey分别为test/Foo，后续用x的test的值去赋值A的Foo
  306.             // 2、遍历src。
  307.             //    第一次遍历：key为Foo。stag/dtag分别为""/test。因此mapping之后
  308.             // skey/dkey分别为test/Foo，后续用x的test的值去赋值A的Foo
  309.             //    第二次遍历：key为test。stag/dtag分别为""/""。因此mapping之后
  310.             // skey/dkey分别为test/test，后续用x的test的值去赋值A的Foo
  311.             skey, dkey = scope.meta.KeyNameMapping(key, stag, dtag)
  312.         }
  314.         // df/sf分别为typeOf(A)/typeOf(A)
  315.         df := dkv.value(dkey)
  316.         sf := skv.value(skey)
  317.         if !df.IsValid() || !sf.IsValid() {
  318.             switch {
  319.             case scope.flags.IsSet(IgnoreMissingFields):
  320.             case scope.flags.IsSet(SourceToDest):
  321.                 return scope.errorf("%v not present in dest", dkey)
  322.             default:
  323.                 return scope.errorf("%v not present in src", skey)
  324.             }
  325.             continue
  326.         }
  327.         scope.srcStack.top().key = skey
  328.         scope.srcStack.top().tag = stag
  329.         scope.destStack.top().key = dkey
  330.         scope.destStack.top().tag = dtag
  331.         // 转换后为TestB A的值等于TestB A的值
  332.         if err := c.convert(sf, df, scope); err != nil {
  333.             return err
  334.         }
  335.     }
  336.     return nil
  337. }
  339. // 基本没有用
  340. // 因为structFieldSources都是空的
  341. func (c *Converter) checkField(fieldName string, skv, dkv kvValue, scope *scope) (bool, error) {
  342.     replacementMade := false
  343.     if scope.flags.IsSet(DestFromSource) {
  344.         df := dkv.value(fieldName)
  345.         if !df.IsValid() {
  346.             return false, nil
  347.         }
  348.         destKey := typeNamePair{df.Type(), fieldName}
  349.         // Check each of the potential source (type, name) pairs to see if they're
  350.         // present in sv.
  351.         for _, potentialSourceKey := range c.structFieldSources[destKey] {
  352.             sf := skv.value(potentialSourceKey.fieldName)
  353.             if !sf.IsValid() {
  354.                 continue
  355.             }
  356.             if sf.Type() == potentialSourceKey.fieldType {
  357.                 // Both the source's name and type matched, so copy.
  358.                 scope.srcStack.top().key = potentialSourceKey.fieldName
  359.                 scope.destStack.top().key = fieldName
  360.                 if err := c.convert(sf, df, scope); err != nil {
  361.                     return true, err
  362.                 }
  363.                 dkv.confirmSet(fieldName, df)
  364.                 replacementMade = true
  365.             }
  366.         }
  367.         return replacementMade, nil
  368.     }
  370.     sf := skv.value(fieldName)
  371.     if !sf.IsValid() {
  372.         return false, nil
  373.     }
  374.     srcKey := typeNamePair{sf.Type(), fieldName}
  375.     // Check each of the potential dest (type, name) pairs to see if they're
  376.     // present in dv.
  377.     for _, potentialDestKey := range c.structFieldDests[srcKey] {
  378.         df := dkv.value(potentialDestKey.fieldName)
  379.         if !df.IsValid() {
  380.             continue
  381.         }
  382.         if df.Type() == potentialDestKey.fieldType {
  383.             // Both the dest's name and type matched, so copy.
  384.             scope.srcStack.top().key = fieldName
  385.             scope.destStack.top().key = potentialDestKey.fieldName
  386.             if err := c.convert(sf, df, scope); err != nil {
  387.                 return true, err
  388.             }
  389.             dkv.confirmSet(potentialDestKey.fieldName, df)
  390.             replacementMade = true
  391.         }
  392.     }
  393.     return replacementMade, nil
  394. }
  396. func (c *Converter) callUntyped(sv, dv reflect.Value, f ConversionFunc, scope *scope) error {
  397.     if !dv.CanAddr() {
  398.         return scope.errorf("cant addr dest")
  399.     }
  400.     var svPointer reflect.Value
  401.     if sv.CanAddr() {
  402.         svPointer = sv.Addr()
  403.     } else {
  404.         svPointer = reflect.New(sv.Type())
  405.         svPointer.Elem().Set(sv)
  406.     }
  407.     dvPointer := dv.Addr()
  408.     return f(svPointer.Interface(), dvPointer.Interface(), scope)
  409. }

4、工具

4.1、adaptor

  1. type kvValue interface {
  2.     keys() []string
  3.     tagOf(key string) reflect.StructTag
  4.     value(key string) reflect.Value
  5.     confirmSet(key string, v reflect.Value) bool
  6. }
  8. type stringMapAdaptor reflect.Value
  10. func (a stringMapAdaptor) len() int {
  11.     return reflect.Value(a).Len()
  12. }
  14. func (a stringMapAdaptor) keys() []string {
  15.     v := reflect.Value(a)
  16.     keys := make([]string, v.Len())
  17.     for i, v := range v.MapKeys() {
  18.         if v.IsNil() {
  19.             continue
  20.         }
  21.         switch t := v.Interface().(type) {
  22.         case string:
  23.             keys[i] = t
  24.         }
  25.     }
  26.     return keys
  27. }
  29. func (a stringMapAdaptor) tagOf(key string) reflect.StructTag {
  30.     return ""
  31. }
  33. func (a stringMapAdaptor) value(key string) reflect.Value {
  34.     return reflect.Value(a).MapIndex(reflect.ValueOf(key))
  35. }
  37. func (a stringMapAdaptor) confirmSet(key string, v reflect.Value) bool {
  38.     return true
  39. }
  41. type structAdaptor reflect.Value
  43. func (a structAdaptor) len() int {
  44.     v := reflect.Value(a)
  45.     return v.Type().NumField()
  46. }
  48. func (a structAdaptor) keys() []string {
  49.     v := reflect.Value(a)
  50.     t := v.Type()
  51.     keys := make([]string, t.NumField())
  52.     for i := range keys {
  53.         keys[i] = t.Field(i).Name
  54.     }
  55.     return keys
  56. }
  58. func (a structAdaptor) tagOf(key string) reflect.StructTag {
  59.     v := reflect.Value(a)
  60.     field, ok := v.Type().FieldByName(key)
  61.     if ok {
  62.         return field.Tag
  63.     }
  64.     return ""
  65. }
  67. func (a structAdaptor) value(key string) reflect.Value {
  68.     v := reflect.Value(a)
  69.     return v.FieldByName(key)
  70. }
  72. func (a structAdaptor) confirmSet(key string, v reflect.Value) bool {
  73.     return true
  74. }

4.2、通用函数

  1. // 切片转换函数
  2. // out可以不用初始化，声明即可
  3. func Convert_Slice_byte_To_Slice_byte(in *[]byte, out *[]byte, s Scope) error {
  4.     if *in == nil {
  5.         *out = nil
  6.         return nil
  7.     }
  8.     *out = make([]byte, len(*in))
  9.     copy(*out, *in)
  10.     return nil
  11. }
  13. // 确保obj为ptr且不为nil并返回obj的Value对象
  14. func EnforcePtr(obj interface{}) (reflect.Value, error) {
  15.     v := reflect.ValueOf(obj)
  16.     if v.Kind() != reflect.Ptr {
  17.         if v.Kind() == reflect.Invalid {
  18.             return reflect.Value{}, fmt.Errorf("expected pointer, but got invalid kind")
  19.         }
  20.         return reflect.Value{}, fmt.Errorf("expected pointer, but got %v type", v.Type())
  21.     }
  22.     if v.IsNil() {
  23.         return reflect.Value{}, fmt.Errorf("expected pointer, but got nil")
  24.     }
  25.     return v.Elem(), nil
  26. }