improve DeepCopy feature for bunch of components, especially the container and gtime (#1956)

container/garray/garray_normal_any.go

@@ -824,6 +824,9 @@ func (a *Array) IsEmpty() bool {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *Array) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]interface{}, len(a.array))

container/garray/garray_normal_int.go

@@ -802,6 +802,9 @@ func (a *IntArray) IsEmpty() bool {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *IntArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]int, len(a.array))

container/garray/garray_normal_str.go

@@ -815,6 +815,9 @@ func (a *StrArray) IsEmpty() bool {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *StrArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]string, len(a.array))

container/garray/garray_sorted_any.go

@@ -800,6 +800,9 @@ func (a *SortedArray) getComparator() func(a, b interface{}) int {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]interface{}, len(a.array))

container/garray/garray_sorted_int.go

@@ -747,6 +747,9 @@ func (a *SortedIntArray) getComparator() func(a, b int) int {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedIntArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]int, len(a.array))

container/garray/garray_sorted_str.go

@@ -760,6 +760,9 @@ func (a *SortedStrArray) getComparator() func(a, b string) int {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedStrArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]string, len(a.array))

container/glist/glist.go

@@ -550,6 +550,10 @@ func (l *List) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (l *List) DeepCopy() interface{} {
+	if l == nil {
+		return nil
+	}
+
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 

container/gmap/gmap_hash_any_any_map.go

@@ -15,6 +15,7 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+// AnyAnyMap wraps map type `map[interface{}]interface{}` and provides more map features.
 type AnyAnyMap struct {
 	mu   rwmutex.RWMutex
 	data map[interface{}]interface{}
@@ -501,6 +502,10 @@ func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *AnyAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[interface{}]interface{}, len(m.data))

container/gmap/gmap_hash_int_any_map.go

@@ -503,6 +503,9 @@ func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[int]interface{}, len(m.data))

container/gmap/gmap_hash_int_int_map.go

@@ -473,6 +473,9 @@ func (m *IntIntMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntIntMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[int]int, len(m.data))

container/gmap/gmap_hash_int_str_map.go

@@ -473,6 +473,9 @@ func (m *IntStrMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntStrMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[int]string, len(m.data))

container/gmap/gmap_hash_str_any_map.go

@@ -489,6 +489,9 @@ func (m *StrAnyMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[string]interface{}, len(m.data))

container/gmap/gmap_hash_str_int_map.go

@@ -477,6 +477,9 @@ func (m *StrIntMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrIntMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[string]int, len(m.data))

container/gmap/gmap_hash_str_str_map.go

@@ -466,6 +466,9 @@ func (m *StrStrMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrStrMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[string]string, len(m.data))

container/gmap/gmap_list_map.go

@@ -594,6 +594,9 @@ func (m *ListMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *ListMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[interface{}]interface{}, len(m.data))

container/gset/gset_any_set.go

@@ -513,6 +513,9 @@ func (set *Set) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (set *Set) DeepCopy() interface{} {
+	if set == nil {
+		return nil
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	data := make(map[interface{}]struct{}, len(set.data))

container/gset/gset_int_set.go

@@ -472,6 +472,9 @@ func (set *IntSet) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (set *IntSet) DeepCopy() interface{} {
+	if set == nil {
+		return nil
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	var (

container/gset/gset_str_set.go

@@ -502,6 +502,9 @@ func (set *StrSet) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (set *StrSet) DeepCopy() interface{} {
+	if set == nil {
+		return nil
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	var (

container/gtype/gtype_bool.go

@@ -99,5 +99,8 @@ func (v *Bool) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Bool) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewBool(v.Val())
 }

container/gtype/gtype_byte.go

@@ -78,5 +78,8 @@ func (v *Byte) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Byte) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewByte(v.Val())
 }

container/gtype/gtype_bytes.go

@@ -86,6 +86,9 @@ func (v *Bytes) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Bytes) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	oldBytes := v.Val()
 	newBytes := make([]byte, len(oldBytes))
 	copy(newBytes, oldBytes)

container/gtype/gtype_float32.go

@@ -90,5 +90,8 @@ func (v *Float32) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Float32) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewFloat32(v.Val())
 }

container/gtype/gtype_float64.go

@@ -90,5 +90,8 @@ func (v *Float64) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Float64) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewFloat64(v.Val())
 }

container/gtype/gtype_int.go

@@ -78,5 +78,8 @@ func (v *Int) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Int) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInt(v.Val())
 }

container/gtype/gtype_int32.go

@@ -78,5 +78,8 @@ func (v *Int32) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Int32) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInt32(v.Val())
 }

container/gtype/gtype_int64.go

@@ -78,5 +78,8 @@ func (v *Int64) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Int64) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInt64(v.Val())
 }

container/gtype/gtype_interface.go

@@ -75,5 +75,8 @@ func (v *Interface) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Interface) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInterface(deepcopy.Copy(v.Val()))
 }

container/gtype/gtype_string.go

@@ -8,8 +8,9 @@ package gtype
 
 import (
 	"bytes"
-	"github.com/gogf/gf/v2/util/gconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // String is a struct for concurrent-safe operation for type string.
@@ -69,3 +70,11 @@ func (v *String) UnmarshalValue(value interface{}) error {
 	v.Set(gconv.String(value))
 	return nil
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (v *String) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
+	return NewString(v.Val())
+}

container/gtype/gtype_uint.go

@@ -78,5 +78,8 @@ func (v *Uint) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Uint) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewUint(v.Val())
 }

container/gtype/gtype_uint32.go

@@ -78,5 +78,8 @@ func (v *Uint32) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Uint32) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewUint32(v.Val())
 }

container/gtype/gtype_uint64.go

@@ -78,5 +78,8 @@ func (v *Uint64) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Uint64) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewUint64(v.Val())
 }

container/gvar/gvar.go

@@ -198,5 +198,8 @@ func (v *Var) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Var) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return New(deepcopy.Copy(v.Val()), v.safe)
 }

internal/deepcopy/deepcopy.go

@@ -57,7 +57,7 @@ func Copy(src interface{}) interface{} {
 // limited support for what it can handle. Add as needed.
 func copyRecursive(original, cpy reflect.Value) {
 	// check for implement deepcopy.Interface
-	if original.CanInterface() {
+	if original.CanInterface() && original.IsValid() && !original.IsZero() {
 		if copier, ok := original.Interface().(Interface); ok {
 			cpy.Set(reflect.ValueOf(copier.DeepCopy()))
 			return

os/gtime/gtime_time.go

@@ -482,5 +482,8 @@ func (t *Time) NoValidation() {}
 
 // DeepCopy implements interface for deep copy of current type.
 func (t *Time) DeepCopy() interface{} {
+	if t == nil {
+		return nil
+	}
 	return New(t.Time)
 }

os/gtime/gtime_z_example_time_test.go

@@ -15,9 +15,7 @@ import (
 	"github.com/gogf/gf/v2/os/gtime"
 )
 
-// New creates and returns a Time object with given parameter.
-// The optional parameter can be type of: time.Time/*time.Time, string or integer.
-func ExampleNew() {
+func ExampleNew_Basic() {
 	curTime := "2018-08-08 08:08:08"
 	timer, _ := time.Parse("2006-01-02 15:04:05", curTime)
 	t1 := gtime.New(&timer)
@@ -40,6 +38,13 @@ func ExampleNew() {
 	// 2018-08-08 08:08:08
 }
 
+func ExampleNew_WithFormat() {
+	fmt.Println(gtime.New("20220629133225", "YmdHis").Format("Y-m-d H:i:s"))
+
+	// Output:
+	// 2022-06-29 13:32:25
+}
+
 // Now creates and returns a time object of now.
 func ExampleNow() {
 	t := gtime.Now()

os/gtime/gtime_z_unit_time_test.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 func Test_New(t *testing.T) {
@@ -407,3 +408,24 @@ func Test_Issue1681(t *testing.T) {
 		t.Assert(gtime.New("2022-03-08T03:01:14+08:00").Local().Time, gtime.New("2022-03-07T19:01:14Z").Local().Time)
 	})
 }
+
+func Test_DeepCopy(t *testing.T) {
+	type User struct {
+		Id          int
+		CreatedTime *gtime.Time
+	}
+	gtest.C(t, func(t *gtest.T) {
+		u1 := &User{
+			Id:          1,
+			CreatedTime: gtime.New("2022-03-08T03:01:14+08:00"),
+		}
+		u2 := gutil.Copy(u1).(*User)
+		t.Assert(u1, u2)
+	})
+	// nil attribute.
+	gtest.C(t, func(t *gtest.T) {
+		u1 := &User{}
+		u2 := gutil.Copy(u1).(*User)
+		t.Assert(u1, u2)
+	})
+}

util/gutil/gutil_z_unit_copy_test.go

@@ -15,6 +15,12 @@ import (
 )
 
 func Test_Copy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gutil.Copy(0), 0)
+		t.Assert(gutil.Copy(1), 1)
+		t.Assert(gutil.Copy("a"), "a")
+		t.Assert(gutil.Copy(nil), nil)
+	})
 	gtest.C(t, func(t *gtest.T) {
 		src := g.Map{
 			"k1": "v1",