merge.go 2.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
  1. // Copyright 2013 Dario Castañé. All rights reserved.
  2. // Copyright 2009 The Go Authors. All rights reserved.
  3. // Use of this source code is governed by a BSD-style
  4. // license that can be found in the LICENSE file.
  5. // Based on src/pkg/reflect/deepequal.go from official
  6. // golang's stdlib.
  7. package mergo
  8. import (
  9. "reflect"
  10. )
  11. // Traverses recursively both values, assigning src's fields values to dst.
  12. // The map argument tracks comparisons that have already been seen, which allows
  13. // short circuiting on recursive types.
  14. func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int) (err error) {
  15. if !src.IsValid() {
  16. return
  17. }
  18. if dst.CanAddr() {
  19. addr := dst.UnsafeAddr()
  20. h := 17 * addr
  21. seen := visited[h]
  22. typ := dst.Type()
  23. for p := seen; p != nil; p = p.next {
  24. if p.ptr == addr && p.typ == typ {
  25. return nil
  26. }
  27. }
  28. // Remember, remember...
  29. visited[h] = &visit{addr, typ, seen}
  30. }
  31. switch dst.Kind() {
  32. case reflect.Struct:
  33. for i, n := 0, dst.NumField(); i < n; i++ {
  34. if err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1); err != nil {
  35. return
  36. }
  37. }
  38. case reflect.Map:
  39. for _, key := range src.MapKeys() {
  40. srcElement := src.MapIndex(key)
  41. if !srcElement.IsValid() {
  42. continue
  43. }
  44. dstElement := dst.MapIndex(key)
  45. switch reflect.TypeOf(srcElement.Interface()).Kind() {
  46. case reflect.Struct:
  47. fallthrough
  48. case reflect.Map:
  49. if err = deepMerge(dstElement, srcElement, visited, depth+1); err != nil {
  50. return
  51. }
  52. }
  53. if !dstElement.IsValid() {
  54. dst.SetMapIndex(key, srcElement)
  55. }
  56. }
  57. case reflect.Ptr:
  58. fallthrough
  59. case reflect.Interface:
  60. if src.IsNil() {
  61. break
  62. } else if dst.IsNil() {
  63. if dst.CanSet() && isEmptyValue(dst) {
  64. dst.Set(src)
  65. }
  66. } else if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1); err != nil {
  67. return
  68. }
  69. default:
  70. if dst.CanSet() && !isEmptyValue(src) {
  71. dst.Set(src)
  72. }
  73. }
  74. return
  75. }
  76. // Merge sets fields' values in dst from src if they have a zero
  77. // value of their type.
  78. // dst and src must be valid same-type structs and dst must be
  79. // a pointer to struct.
  80. // It won't merge unexported (private) fields and will do recursively
  81. // any exported field.
  82. func Merge(dst, src interface{}) error {
  83. var (
  84. vDst, vSrc reflect.Value
  85. err error
  86. )
  87. if vDst, vSrc, err = resolveValues(dst, src); err != nil {
  88. return err
  89. }
  90. if vDst.Type() != vSrc.Type() {
  91. return ErrDifferentArgumentsTypes
  92. }
  93. return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0)
  94. }