pointer

Author: spirin

README.md

@@ -0,0 +1,41 @@
+# Pointer
+
+A tool, that helps to create pointers on the fly.
+
+For APIs, tests, etc
+
+Usage:
+
+```go
+
+import "github.com/spirin/pointer"
+
+type Bar{}
+
+func main() {
+    pObj := pointer.Of(Bar{})
+    
+    pString := pointer.Of("some string")
+
+    pIntA := pointer.Of(1)
+    pIntB := pointer.Of(2)
+    
+    if pointer.Equal(pIntA, pIntB){
+        ...
+    }
+
+    if pointer.EqualValue(pIntA, 123){
+        ...
+    }
+    
+    fmt.Println(pointer.Value(pIntB, 123))
+    
+    // types that cannot be autoresolved
+    
+    pInt64 := pointer.Int64(1)
+    
+    pFloat16 := pointer.Float16(1)
+    
+    ...
+}
+```

go.mod

@@ -0,0 +1,11 @@
+module github.com/spirin/pointer
+
+go 1.18
+
+require github.com/stretchr/testify v1.8.4
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,10 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

pointer.go

@@ -0,0 +1,84 @@
+package pointer
+
+// any types
+
+func Of[T any](v T) *T {
+	return &v
+}
+
+func Value[T any](v *T, def T) T {
+	if v == nil {
+		return def
+	}
+
+	return *v
+}
+
+func Equal[T comparable](a *T, b *T) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a != nil && b != nil {
+		return *a == *b
+	}
+
+	return false
+}
+
+func EqualValue[T comparable](p *T, v T) bool {
+	if p == nil {
+		return false
+	}
+
+	return *p == v
+}
+
+// non autoresolveable types
+
+func Int8(v int8) *int8 {
+	return Of(v)
+}
+
+func Int16(v int16) *int16 {
+	return Of(v)
+}
+
+func Int32(v int32) *int32 {
+	return Of(v)
+}
+
+func Int64(v int64) *int64 {
+	return Of(v)
+}
+
+func UInt8(v uint8) *uint8 {
+	return Of(v)
+}
+
+func UInt16(v uint16) *uint16 {
+	return Of(v)
+}
+
+func UInt32(v uint32) *uint32 {
+	return Of(v)
+}
+
+func UInt64(v uint64) *uint64 {
+	return Of(v)
+}
+
+func Float32(v float32) *float32 {
+	return Of(v)
+}
+
+func Float64(v float64) *float64 {
+	return Of(v)
+}
+
+func Complex64(v complex64) *complex64 {
+	return Of(v)
+}
+
+func Complex128(v complex128) *complex128 {
+	return Of(v)
+}

pointer_test.go

@@ -0,0 +1,185 @@
+package pointer
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOf(t *testing.T) {
+	tests := []struct {
+		name   string
+		target any
+	}{
+		{
+			name:   "string type",
+			target: "test",
+		},
+		{
+			name:   "int type",
+			target: 2,
+		},
+		{
+			name: "time type",
+			target: func() time.Time {
+				date, err := time.Parse(time.RFC3339, "2022-01-01T12:30:00Z")
+				require.NoError(t, err)
+				return date
+			}(),
+		},
+		{
+			name:   "uint32 type",
+			target: uint32(4),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Of(tt.target)
+			require.True(t, reflect.ValueOf(result).Kind() == reflect.Ptr)
+		})
+	}
+}
+
+func TestValue(t *testing.T) {
+	var v = 12.5
+	if got := Value(Of(v), 0); got != v {
+		t.Errorf("Value() = %v, want %v", got, &v)
+	}
+}
+
+func TestValueWithDefault(t *testing.T) {
+	var v = 12.5
+	if got := Value(nil, v); got != v {
+		t.Errorf("Value() = %v, want %v", got, &v)
+	}
+}
+
+func TestEqual(t *testing.T) {
+	testCases := []struct {
+		name string
+		a    *int
+		b    *int
+		want bool
+	}{
+		{name: "a, b nil", want: true},
+		{name: "a nill, b not", b: Of(1), want: false},
+		{name: "a not, b nil", a: Of(1), want: false},
+		{name: "a, b not equal", a: Of(1), b: Of(2), want: false},
+		{name: "a, b equal", a: Of(1), b: Of(1), want: true},
+	}
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := Equal(tt.a, tt.b); got != tt.want {
+				t.Errorf("Equal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestEqualValue(t *testing.T) {
+	testCases := []struct {
+		name string
+		p    *int
+		v    int
+		want bool
+	}{
+		{name: "p nil", v: 123, want: false},
+		{name: "p not nil, not eq", p: Of(999), v: 123, want: false},
+		{name: "p not nil, eq", p: Of(123), v: 123, want: true},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := EqualValue(tt.p, tt.v); got != tt.want {
+				t.Errorf("Equal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestInt8(t *testing.T) {
+	var v = int8(1)
+	if got := Int8(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Int8() = %v, want %v", got, &v)
+	}
+}
+
+func TestInt16(t *testing.T) {
+	var v = int16(1)
+	if got := Int16(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Int16() = %v, want %v", got, &v)
+	}
+}
+
+func TestInt32(t *testing.T) {
+	var v = int32(1)
+	if got := Int32(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Int32() = %v, want %v", got, &v)
+	}
+}
+
+func TestInt64(t *testing.T) {
+	var v = int64(1)
+	if got := Int64(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Int64() = %v, want %v", got, &v)
+	}
+}
+
+func TestUInt8(t *testing.T) {
+	var v = uint8(1)
+	if got := UInt8(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("UInt8() = %v, want %v", got, &v)
+	}
+}
+
+func TestUInt16(t *testing.T) {
+	var v = uint16(1)
+	if got := UInt16(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("UInt16() = %v, want %v", got, &v)
+	}
+}
+
+func TestUInt32(t *testing.T) {
+	var v = uint32(1)
+	if got := UInt32(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("UInt32() = %v, want %v", got, &v)
+	}
+}
+
+func TestUInt64(t *testing.T) {
+	var v = uint64(1)
+	if got := UInt64(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("UInt64() = %v, want %v", got, &v)
+	}
+}
+
+func TestFloat32(t *testing.T) {
+	var v = float32(1)
+	if got := Float32(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Float32() = %v, want %v", got, &v)
+	}
+}
+
+func TestFloat64(t *testing.T) {
+	var v = float64(1)
+	if got := Float64(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Float64() = %v, want %v", got, &v)
+	}
+}
+
+func TestComplex64(t *testing.T) {
+	var v = complex64(1)
+	if got := Complex64(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Complex64() = %v, want %v", got, &v)
+	}
+}
+
+func TestComplex128(t *testing.T) {
+	var v = complex128(1)
+	if got := Complex128(v); !reflect.DeepEqual(got, &v) {
+		t.Errorf("Complex128() = %v, want %v", got, &v)
+	}
+}