Add method for retrieving a pointer to a field.

field.go

@@ -61,27 +61,28 @@ func (s *StructMeta) Type(v interface{}) *StructMeta {
 	return s
 }
 
-// SetValue sets the value of the currently selected field.
-func (s *StructMeta) SetValue(v interface{}) *StructMeta {
-	s.Type(v)
+// Value retrieves the value of the selected field.
+func (s *StructMeta) Value() (interface{}, error) {
 	if s.err != nil {
-		return s
+		return nil, s.err
 	}
-	if !s.field.CanSet() {
-		s.err = errFieldReadOnly
-		return s
+	if !s.field.IsValid() {
+		return nil, errFieldNotSelected
 	}
-	s.field.Set(reflect.ValueOf(v))
-	return s
+	return s.field.Interface(), nil
 }
 
-// Value retrieves the value of the selected field.
-func (s *StructMeta) Value() (interface{}, error) {
+// Addr retrieves a pointer to the selected field.
+// This method will return an error if the field is read-only.
+func (s *StructMeta) Addr() (interface{}, error) {
 	if s.err != nil {
 		return nil, s.err
 	}
 	if !s.field.IsValid() {
 		return nil, errFieldNotSelected
 	}
-	return s.field.Interface(), nil
+	if !s.field.CanAddr() {
+		return nil, errFieldReadOnly
+	}
+	return s.field.Addr().Interface(), nil
 }

field_test.go

@@ -67,38 +67,6 @@ func TestType(t *testing.T) {
 	}
 }
 
-func TestBadSetValue(t *testing.T) {
-	if err := Struct(&testFieldStruct{}).
-		Field("field0").
-		SetValue("").
-		Error(); err != errFieldReadOnly {
-		t.Fatalf("%v != %v", err, errFieldReadOnly)
-	}
-}
-
-func TestSetValue(t *testing.T) {
-	s := &testFieldStruct{}
-	if err := Struct(s).
-		Field("Field1").
-		SetValue(strTest).
-		Field("Field2").
-		SetValue(intTest).
-		Field("Field3").
-		SetValue(errTest).
-		Error(); err != nil {
-		t.Fatal(err)
-	}
-	if s.Field1 != strTest {
-		t.Fatalf("%v != %v", s.Field1, strTest)
-	}
-	if s.Field2 != intTest {
-		t.Fatalf("%v != %v", s.Field2, intTest)
-	}
-	if s.Field3 != errTest {
-		t.Fatalf("%v != %v", s.Field3, errTest)
-	}
-}
-
 func TestBadValue(t *testing.T) {
 	if _, err := Struct(&testFieldStruct{}).
 		Value(); err != errFieldNotSelected {
@@ -128,3 +96,37 @@ func TestValue(t *testing.T) {
 		t.Fatalf("%v != %v", v.(error), errTest)
 	}
 }
+
+func TestBadAddr(t *testing.T) {
+	if _, err := Struct(&testFieldStruct{}).
+		Addr(); err != errFieldNotSelected {
+		t.Fatalf("%v != %v", err, errFieldNotSelected)
+	}
+	if _, err := Struct(testFieldStruct{}).
+		Field("Field1").
+		Addr(); err != errFieldReadOnly {
+		t.Fatalf("%v != %v", err, errFieldReadOnly)
+	}
+}
+
+func TestAddr(t *testing.T) {
+	var (
+		f = &testFieldStruct{}
+		s = Struct(f)
+	)
+	if v, err := s.Field("Field1").Addr(); err != nil {
+		t.Fatal(err)
+	} else if *v.(*string) = strTest; f.Field1 != strTest {
+		t.Fatalf("%v != %v", f.Field1, strTest)
+	}
+	if v, err := s.Field("Field2").Addr(); err != nil {
+		t.Fatal(err)
+	} else if *v.(*int) = intTest; f.Field2 != intTest {
+		t.Fatalf("%v != %v", f.Field2, intTest)
+	}
+	if v, err := s.Field("Field3").Addr(); err != nil {
+		t.Fatal(err)
+	} else if *v.(*error) = errTest; f.Field3 != errTest {
+		t.Fatalf("%v != %v", f.Field3, errTest)
+	}
+}

struct_test.go

@@ -43,16 +43,21 @@ func TestIsPtr(t *testing.T) {
 func TestError(t *testing.T) {
 	s := Struct(&testStructStruct{})
 	s.err = errTest
-	if _, err := s.
+	if err := s.
 		Method("42").
 		Param(3, "").
 		Params().
 		Return(3, "").
 		Returns().
 		Field("42").
 		Type("").
-		SetValue("").
-		Value(); err != errTest {
+		Error(); err != errTest {
+		t.Fatalf("%v != %v", err, errTest)
+	}
+	if _, err := s.Value(); err != errTest {
+		t.Fatalf("%v != %v", err, errTest)
+	}
+	if _, err := s.Addr(); err != errTest {
 		t.Fatalf("%v != %v", err, errTest)
 	}
 }