Valuer interface

copier.go

@@ -94,6 +94,15 @@ type FieldNameMapping struct {
 	Mapping map[string]string
 }
 
+// Valuer lets custom types implement a function returning the actual value to copy.
+// For example if your type is a wrapper, or if it doesn't have to implement `sql/driver.Valuer`,
+// you can implement this interface so the returned value will be used instead. It can also be used
+// to format your type or convert it to another one before being copied.
+// This also enables conversion for types using generics, as you cannot use them with `TypeConverter`.
+type Valuer interface {
+	CopyValue() interface{}
+}
+
 // Tag Flags
 type flags struct {
 	BitFlags  map[string]uint8
@@ -118,6 +127,11 @@ func CopyWithOption(toValue interface{}, fromValue interface{}, opt Option) (err
 }
 
 func copier(toValue interface{}, fromValue interface{}, opt Option) (err error) {
+
+	if fromCopyValuer, ok := fromValue.(Valuer); ok {
+		fromValue = fromCopyValuer.CopyValue()
+	}
+
 	var (
 		isSlice    bool
 		amount     = 1
@@ -558,6 +572,11 @@ func set(to, from reflect.Value, deepCopy bool, converters map[converterPair]Typ
 	if !from.IsValid() {
 		return true, nil
 	}
+
+	if fromCopyValuer, ok := copyValuer(from); ok {
+		from = reflect.ValueOf(fromCopyValuer.CopyValue())
+	}
+
 	if ok, err := lookupAndCopyWithConverter(to, from, converters); err != nil {
 		return false, err
 	} else if ok {
@@ -819,6 +838,16 @@ func driverValuer(v reflect.Value) (i driver.Valuer, ok bool) {
 	return
 }
 
+func copyValuer(v reflect.Value) (i Valuer, ok bool) {
+	if !v.CanAddr() {
+		i, ok = v.Interface().(Valuer)
+		return
+	}
+
+	i, ok = v.Addr().Interface().(Valuer)
+	return
+}
+
 func fieldByName(v reflect.Value, name string, caseSensitive bool) reflect.Value {
 	if caseSensitive {
 		return v.FieldByName(name)

copier_test.go

@@ -1762,3 +1762,35 @@ func TestNestedNilPointerStruct(t *testing.T) {
 		t.Errorf("to (%v) value should equal from (%v) value", to.Title, from.Title)
 	}
 }
+
+type testValuer struct {
+	Value interface{}
+}
+
+func (v testValuer) CopyValue() interface{} {
+	return v.Value
+}
+
+func TestCopyValuer(t *testing.T) {
+
+	to := struct {
+		Value string
+	}{
+		Value: "initial",
+	}
+
+	from := struct {
+		Value testValuer
+	}{
+		Value: testValuer{Value: "override"},
+	}
+
+	err := copier.Copy(&to, from)
+	if err != nil {
+		t.Errorf("should not error: %v", err)
+	}
+
+	if to.Value != from.Value.Value {
+		t.Errorf("to (%v) value should equal to from (%v) value", to.Value, from.Value.Value)
+	}
+}