Merge pull request #25 from vancluever/add-pointer-value-walker

Add PointerValueWalker for walking pointer values

Author: mitchellh

reflectwalk.go

@@ -69,6 +69,13 @@ type PointerWalker interface {
 	PointerExit(bool) error
 }
 
+// PointerValueWalker implementations are notified with the value of
+// a particular pointer when a pointer is walked. Pointer is called
+// right before PointerEnter.
+type PointerValueWalker interface {
+	Pointer(reflect.Value) error
+}
+
 // SkipEntry can be returned from walk functions to skip walking
 // the value of this field. This is only valid in the following functions:
 //
@@ -130,6 +137,17 @@ func walk(v reflect.Value, w interface{}) (err error) {
 		}
 
 		if pointerV.Kind() == reflect.Ptr {
+			if pw, ok := w.(PointerValueWalker); ok {
+				if err = pw.Pointer(pointerV); err != nil {
+					if err == SkipEntry {
+						// Skip the rest of this entry but clear the error
+						return nil
+					}
+
+					return
+				}
+			}
+
 			pointer = true
 			v = reflect.Indirect(pointerV)
 		}

reflectwalk_test.go

@@ -49,6 +49,20 @@ func (t *TestPointerWalker) PointerExit(v bool) error {
 	return nil
 }
 
+type TestPointerValueWalker struct {
+	skip     bool
+	pointers []reflect.Type
+}
+
+func (t *TestPointerValueWalker) Pointer(v reflect.Value) error {
+	t.pointers = append(t.pointers, v.Type())
+	if t.skip {
+		return SkipEntry
+	}
+
+	return nil
+}
+
 type TestPrimitiveWalker struct {
 	Value reflect.Value
 }
@@ -482,6 +496,61 @@ func TestWalk_PointerPointer(t *testing.T) {
 	}
 }
 
+func TestWalk_PointerValue(t *testing.T) {
+	type X struct{}
+	type T struct {
+		x *X
+	}
+
+	v := &T{x: &X{}}
+
+	expected := []reflect.Type{
+		reflect.TypeOf(v),
+		reflect.TypeOf(v.x),
+	}
+
+	w := new(TestPointerValueWalker)
+	err := Walk(v, w)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(expected, w.pointers) {
+		t.Fatalf("unexpected pointer order or length (expected len=%d, actual len=%d)", len(expected), len(w.pointers))
+	}
+}
+
+func TestWalk_PointerValueSkip(t *testing.T) {
+	type T struct{}
+	type W struct {
+		TestPointerValueWalker
+		TestPointerWalker
+	}
+
+	v := &T{}
+	w := &W{
+		TestPointerValueWalker: TestPointerValueWalker{
+			skip: true,
+		},
+	}
+	err := Walk(v, w)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(w.TestPointerValueWalker.pointers) != 1 {
+		t.Errorf("expected len=1, got len=%d", len(w.TestPointerValueWalker.pointers))
+	}
+
+	if w.TestPointerValueWalker.pointers[0] != reflect.TypeOf(v) {
+		t.Error("pointer value type mismatch")
+	}
+
+	if w.enters != 0 || w.exits != 0 {
+		t.Error("should have been skipped and have zero enters or exits")
+	}
+}
+
 func TestWalk_Slice(t *testing.T) {
 	w := new(TestSliceWalker)