add feature nested pointer support(#21)

Author: zhlingbo

README.md

@@ -66,6 +66,40 @@ fmt.Println(example.Bar) //Prints: 0
 
 ```
 
+Pointer Set
+-------
+
+Pointer field struct is a tricky usage to avoid covering existed values. 
+
+Take the basic example in the above section and change it slightly:
+```go
+
+type ExamplePointer struct {
+    Foo *bool   `default:"true"` //<-- StructTag with a default key
+    Bar *string `default:"example"`
+    Qux *int    `default:"22"`
+    Oed *int64  `default:"64"`
+}
+
+...
+
+boolZero := false
+stringZero := ""
+intZero := 0
+example := ExamplePointer{
+    Foo: &boolZero,
+    Bar: &stringZero,
+    Qux: &intZero,
+}
+defaults.SetDefaults(example)
+
+fmt.Println(*example.Foo) //Prints: false (zero value `false` for bool but not for bool ptr)
+fmt.Println(*example.Bar) //Prints: "" (print "" which set in advance, not "example" for default)
+fmt.Println(*example.Qux) //Prints: 0 (0 instead of 22)
+fmt.Println(*example.Oed) //Prints: 64 (64, because the ptr addr is nil when SetDefaults)
+
+```
+
 License
 -------
 

defaults.go

@@ -12,15 +12,16 @@ import (
 // the StructTag with name "default" and the directed value.
 //
 // Usage
-//     type ExampleBasic struct {
-//         Foo bool   `default:"true"`
-//         Bar string `default:"33"`
-//         Qux int8
-//         Dur time.Duration `default:"2m3s"`
-//     }
 //
-//      foo := &ExampleBasic{}
-//      SetDefaults(foo)
+//	type ExampleBasic struct {
+//	    Foo bool   `default:"true"`
+//	    Bar string `default:"33"`
+//	    Qux int8
+//	    Dur time.Duration `default:"2m3s"`
+//	}
+//
+//	 foo := &ExampleBasic{}
+//	 SetDefaults(foo)
 func SetDefaults(variable interface{}) {
 	getDefaultFiller().Fill(variable)
 }
@@ -90,7 +91,11 @@ func newDefaultFiller() *Filler {
 	types := make(map[TypeHash]FillerFunc, 1)
 	types["time.Duration"] = func(field *FieldData) {
 		d, _ := time.ParseDuration(field.TagValue)
-		field.Value.Set(reflect.ValueOf(d))
+		if field.Value.Kind() == reflect.Ptr {
+			field.Value.Set(reflect.ValueOf(&d))
+		} else {
+			field.Value.Set(reflect.ValueOf(d))
+		}
 	}
 
 	funcs[reflect.Slice] = func(field *FieldData) {
@@ -134,6 +139,70 @@ func newDefaultFiller() *Filler {
 		}
 	}
 
+	funcs[reflect.Ptr] = func(field *FieldData) {
+		if field.TagValue == "" {
+			return
+		}
+		switch field.Value.Type().Elem().Kind() {
+		case reflect.Bool:
+			value, _ := strconv.ParseBool(field.TagValue)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Int:
+			v, _ := strconv.ParseInt(field.TagValue, 10, 64)
+			value := int(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Int8:
+			v, _ := strconv.ParseInt(field.TagValue, 10, 64)
+			value := int8(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Int16:
+			v, _ := strconv.ParseInt(field.TagValue, 10, 64)
+			value := int16(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Int32:
+			v, _ := strconv.ParseInt(field.TagValue, 10, 64)
+			value := int32(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Int64:
+			if field.Field.Type == reflect.TypeOf(time.Second) {
+				value, _ := time.ParseDuration(field.TagValue)
+				field.Value.Set(reflect.ValueOf(&value))
+			} else {
+				value, _ := strconv.ParseInt(field.TagValue, 10, 64)
+				field.Value.Set(reflect.ValueOf(&value))
+			}
+		case reflect.Uint:
+			v, _ := strconv.ParseUint(field.TagValue, 10, 64)
+			value := uint(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Uint8:
+			v, _ := strconv.ParseUint(field.TagValue, 10, 64)
+			value := uint8(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Uint16:
+			v, _ := strconv.ParseUint(field.TagValue, 10, 64)
+			value := uint16(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Uint32:
+			v, _ := strconv.ParseUint(field.TagValue, 10, 64)
+			value := uint32(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Uint64:
+			value, _ := strconv.ParseUint(field.TagValue, 10, 64)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Float32:
+			v, _ := strconv.ParseFloat(field.TagValue, 64)
+			value := float32(v)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.Float64:
+			value, _ := strconv.ParseFloat(field.TagValue, 64)
+			field.Value.Set(reflect.ValueOf(&value))
+		case reflect.String:
+			tagValue := parseDateTimeString(field.TagValue)
+			field.Value.Set(reflect.ValueOf(&tagValue))
+		}
+	}
+
 	return &Filler{FuncByKind: funcs, FuncByType: types, Tag: "default"}
 }
 

defaults_test.go

@@ -61,6 +61,22 @@ type ExampleBasic struct {
 	StringSliceSlice [][]string    `default:"[[1],[]]"`
 
 	DateTime string `default:"{{date:1,-10,0}} {{time:1,-5,10}}"`
+
+	BoolPtr     *bool          `default:"false"`
+	IntPtr      *int           `default:"33"`
+	Int8Ptr     *int8          `default:"8"`
+	Int16Ptr    *int16         `default:"16"`
+	Int32Ptr    *int32         `default:"32"`
+	Int64Ptr    *int64         `default:"64"`
+	UIntPtr     *uint          `default:"11"`
+	UInt8Ptr    *uint8         `default:"18"`
+	UInt16Ptr   *uint16        `default:"116"`
+	UInt32Ptr   *uint32        `default:"132"`
+	UInt64Ptr   *uint64        `default:"164"`
+	Float32Ptr  *float32       `default:"3.2"`
+	Float64Ptr  *float64       `default:"6.4"`
+	DurationPtr *time.Duration `default:"1s"`
+	SecondPtr   *time.Duration `default:"1s"`
 }
 
 func (s *DefaultsSuite) TestSetDefaultsBasic(c *C) {
@@ -106,6 +122,21 @@ func (s *DefaultsSuite) assertTypes(c *C, foo *ExampleBasic) {
 	c.Assert(foo.IntSliceSlice, DeepEquals, [][]int{[]int{1}, []int{2}, []int{3}, []int{4}})
 	c.Assert(foo.StringSliceSlice, DeepEquals, [][]string{[]string{"1"}, []string{}})
 	c.Assert(foo.DateTime, Equals, "2020-08-10 12:55:10")
+	c.Assert(*foo.BoolPtr, Equals, false)
+	c.Assert(*foo.IntPtr, Equals, 33)
+	c.Assert(*foo.Int8Ptr, Equals, int8(8))
+	c.Assert(*foo.Int16Ptr, Equals, int16(16))
+	c.Assert(*foo.Int32Ptr, Equals, int32(32))
+	c.Assert(*foo.Int64Ptr, Equals, int64(64))
+	c.Assert(*foo.UIntPtr, Equals, uint(11))
+	c.Assert(*foo.UInt8Ptr, Equals, uint8(18))
+	c.Assert(*foo.UInt16Ptr, Equals, uint16(116))
+	c.Assert(*foo.UInt32Ptr, Equals, uint32(132))
+	c.Assert(*foo.UInt64Ptr, Equals, uint64(164))
+	c.Assert(*foo.Float32Ptr, Equals, float32(3.2))
+	c.Assert(*foo.Float64Ptr, Equals, 6.4)
+	c.Assert(*foo.DurationPtr, Equals, time.Second)
+	c.Assert(*foo.SecondPtr, Equals, time.Second)
 }
 
 func (s *DefaultsSuite) TestSetDefaultsWithValues(c *C) {
@@ -118,6 +149,9 @@ func (s *DefaultsSuite) TestSetDefaultsWithValues(c *C) {
 		Children: []Child{{Name: "alice"}, {Name: "bob", Age: 2}},
 	}
 
+	intzero := 0
+	foo.IntPtr = &intzero
+
 	SetDefaults(foo)
 
 	c.Assert(foo.Integer, Equals, 55)
@@ -127,6 +161,8 @@ func (s *DefaultsSuite) TestSetDefaultsWithValues(c *C) {
 	c.Assert(string(foo.Bytes), Equals, "foo")
 	c.Assert(foo.Children[0].Age, Equals, 10)
 	c.Assert(foo.Children[1].Age, Equals, 2)
+
+	c.Assert(*foo.IntPtr, Equals, 0)
 }
 
 func (s *DefaultsSuite) BenchmarkLogic(c *C) {

filler.go

@@ -87,6 +87,8 @@ func (f *Filler) isEmpty(field *FieldData) bool {
 		}
 	case reflect.String:
 		return field.Value.String() == ""
+	case reflect.Ptr:
+		return field.Value.IsZero()
 	}
 	return true
 }