feat: add pointer conversion helpers to convert

Author: alkanna

convert/conv.go

@@ -1,96 +1,138 @@
 package convert
 
 import (
-	"strconv"
-	"strings"
-	"time"
+  "strconv"
+  "strings"
+  "time"
 )
 
 // ToFloat converts string to float64. It returns 0 if conversion is impossible.
 func ToFloat(s string) float32 {
-	f, _ := strconv.ParseFloat(strings.Replace(s, ",", ".", -1), 32)
+  f, _ := strconv.ParseFloat(strings.Replace(s, ",", ".", -1), 32)
 
-	return float32(f)
+  return float32(f)
 }
 
 // ToFloat64 converts string to float64. It returns 0 if conversion is impossible.
 func ToFloat64(s string) float64 {
-	f, _ := strconv.ParseFloat(strings.Replace(s, ",", ".", -1), 64)
+  f, _ := strconv.ParseFloat(strings.Replace(s, ",", ".", -1), 64)
 
-	return f
+  return f
 }
 
 // ToInt converts string to int. It returns 0 if conversion is impossible.
 func ToInt(s string) int {
-	i, _ := strconv.Atoi(s)
+  i, _ := strconv.Atoi(s)
 
-	return i
+  return i
 }
 
 // ToInt64 converts string to int64. It returns 0 if conversion is impossible.
 func ToInt64(s string) int64 {
-	i, _ := strconv.ParseInt(s, 0, 64)
+  i, _ := strconv.ParseInt(s, 0, 64)
 
-	return i
+  return i
 }
 
 func PointerTo[T any](v T) *T {
-	return &v
+  return &v
+}
+
+// PointerToOrNil returns a pointer to v if condition is true, otherwise returns nil.
+// This is useful for conditionally setting optional fields in API requests.
+//
+// Example:
+//
+//	latitude := convert.PointerToOrNil(geo.Latitude, geo != nil && geo.Latitude != 0)
+func PointerToOrNil[T any](v T, condition bool) *T {
+  if condition {
+    return &v
+  }
+  return nil
+}
+
+// PointerToIf returns a pointer to v if the predicate function returns true, otherwise returns nil.
+// This is useful for conditional pointer creation with complex validation logic.
+//
+// Example:
+//
+//	isValid := func(lat float64) bool { return lat >= -90 && lat <= 90 }
+//	latitude := convert.PointerToIf(geo.Latitude, isValid)
+func PointerToIf[T any](v T, predicate func(T) bool) *T {
+  if predicate(v) {
+    return &v
+  }
+  return nil
+}
+
+// PointerToIfNonZero returns a pointer to v if v is not the zero value for its type, otherwise returns nil.
+// This is a convenience wrapper for the common case of checking non-zero values.
+//
+// Example:
+//
+//	name := convert.PointerToIfNonZero("John") // returns &"John"
+//	empty := convert.PointerToIfNonZero("")    // returns nil
+func PointerToIfNonZero[T comparable](v T) *T {
+  var zero T
+  if v != zero {
+    return &v
+  }
+  return nil
 }
 
 // Deprecated: use PointerTo instead.
 func BoolP(v bool) *bool {
-	return &v
+  return &v
 }
 
 // Deprecated: use PointerTo instead.
 func Float64P(v float64) *float64 {
-	return &v
+  return &v
 }
 
 // Deprecated: use PointerTo instead.
 func FloatP(v float32) *float32 {
-	return &v
+  return &v
 }
 
 // Deprecated: use PointerTo instead.
 func Int64P(v int64) *int64 {
-	return &v
+  return &v
 }
 
 // Deprecated: use PointerTo instead.
 func IntP(v int) *int {
-	return &v
+  return &v
 }
 
 // Deprecated: use PointerTo instead.
 func StrP(s string) *string {
-	return &s
+  return &s
 }
 
 // Deprecated: use PointerTo instead.
 func TimeP(t time.Time) *time.Time {
-	return &t
+  return &t
 }
 
 func EqualInt64P(a, b *int64) bool {
-	if a == b {
-		return true
-	}
+  if a == b {
+    return true
+  }
 
-	if a == nil || b == nil {
-		return false
-	}
+  if a == nil || b == nil {
+    return false
+  }
 
-	return *a == *b
+  return *a == *b
 }
 
 // Float32ToString converts a float32 to a string.
 func Float32ToString(f float32) string {
-	return strconv.FormatFloat(float64(f), 'f', -1, 32)
+  return strconv.FormatFloat(float64(f), 'f', -1, 32)
 }
 
 // Float64ToString converts a float64 to a string.
 func Float64ToString(f float64) string {
-	return strconv.FormatFloat(f, 'f', -1, 64)
+  return strconv.FormatFloat(f, 'f', -1, 64)
 }

convert/conv_test.go

@@ -0,0 +1,195 @@
+package convert
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPointerToOrNil(t *testing.T) {
+	t.Run("int with true condition", func(t *testing.T) {
+		result := PointerToOrNil(42, true)
+		assert.NotNil(t, result)
+		assert.Equal(t, 42, *result)
+	})
+
+	t.Run("int with false condition", func(t *testing.T) {
+		result := PointerToOrNil(42, false)
+		assert.Nil(t, result)
+	})
+
+	t.Run("zero value with true condition", func(t *testing.T) {
+		result := PointerToOrNil(0, true)
+		assert.NotNil(t, result)
+		assert.Equal(t, 0, *result)
+	})
+
+	t.Run("string with true condition", func(t *testing.T) {
+		result := PointerToOrNil("hello", true)
+		assert.NotNil(t, result)
+		assert.Equal(t, "hello", *result)
+	})
+
+	t.Run("empty string with false condition", func(t *testing.T) {
+		result := PointerToOrNil("", false)
+		assert.Nil(t, result)
+	})
+
+	t.Run("float64 with condition", func(t *testing.T) {
+		result := PointerToOrNil(3.14, true)
+		assert.NotNil(t, result)
+		assert.Equal(t, 3.14, *result)
+
+		resultNil := PointerToOrNil(3.14, false)
+		assert.Nil(t, resultNil)
+	})
+
+	t.Run("struct with true condition", func(t *testing.T) {
+		type testStruct struct {
+			x int
+			y string
+		}
+		val := testStruct{x: 42, y: "test"}
+		result := PointerToOrNil(val, true)
+		assert.NotNil(t, result)
+		assert.Equal(t, val, *result)
+	})
+}
+
+func TestPointerToIf(t *testing.T) {
+	t.Run("predicate returns true", func(t *testing.T) {
+		result := PointerToIf(42, func(v int) bool { return v > 0 })
+		assert.NotNil(t, result)
+		assert.Equal(t, 42, *result)
+	})
+
+	t.Run("predicate returns false", func(t *testing.T) {
+		result := PointerToIf(-5, func(v int) bool { return v > 0 })
+		assert.Nil(t, result)
+	})
+
+	t.Run("complex predicate - latitude range check valid", func(t *testing.T) {
+		isValidLatitude := func(v float64) bool {
+			return v >= -90 && v <= 90
+		}
+		result := PointerToIf(45.5, isValidLatitude)
+		assert.NotNil(t, result)
+		assert.Equal(t, 45.5, *result)
+	})
+
+	t.Run("complex predicate - latitude out of range", func(t *testing.T) {
+		isValidLatitude := func(v float64) bool {
+			return v >= -90 && v <= 90
+		}
+		result := PointerToIf(100.0, isValidLatitude)
+		assert.Nil(t, result)
+	})
+
+	t.Run("string length predicate", func(t *testing.T) {
+		isNotEmpty := func(s string) bool { return len(s) > 0 }
+		result := PointerToIf("hello", isNotEmpty)
+		assert.NotNil(t, result)
+		assert.Equal(t, "hello", *result)
+
+		resultEmpty := PointerToIf("", isNotEmpty)
+		assert.Nil(t, resultEmpty)
+	})
+
+	t.Run("zero value with predicate that accepts it", func(t *testing.T) {
+		alwaysTrue := func(v int) bool { return true }
+		result := PointerToIf(0, alwaysTrue)
+		assert.NotNil(t, result)
+		assert.Equal(t, 0, *result)
+	})
+}
+
+func TestPointerToIfNonZero(t *testing.T) {
+	t.Run("non-zero int", func(t *testing.T) {
+		result := PointerToIfNonZero(42)
+		assert.NotNil(t, result)
+		assert.Equal(t, 42, *result)
+	})
+
+	t.Run("zero int", func(t *testing.T) {
+		result := PointerToIfNonZero(0)
+		assert.Nil(t, result)
+	})
+
+	t.Run("non-empty string", func(t *testing.T) {
+		result := PointerToIfNonZero("hello")
+		assert.NotNil(t, result)
+		assert.Equal(t, "hello", *result)
+	})
+
+	t.Run("empty string", func(t *testing.T) {
+		result := PointerToIfNonZero("")
+		assert.Nil(t, result)
+	})
+
+	t.Run("non-zero float64", func(t *testing.T) {
+		result := PointerToIfNonZero(3.14)
+		assert.NotNil(t, result)
+		assert.Equal(t, 3.14, *result)
+	})
+
+	t.Run("zero float64", func(t *testing.T) {
+		result := PointerToIfNonZero(0.0)
+		assert.Nil(t, result)
+	})
+
+	t.Run("negative int is non-zero", func(t *testing.T) {
+		result := PointerToIfNonZero(-5)
+		assert.NotNil(t, result)
+		assert.Equal(t, -5, *result)
+	})
+
+	t.Run("negative float is non-zero", func(t *testing.T) {
+		result := PointerToIfNonZero(-3.14)
+		assert.NotNil(t, result)
+		assert.Equal(t, -3.14, *result)
+	})
+}
+
+// Example tests for documentation
+
+func ExamplePointerToOrNil() {
+	type GeoLocation struct {
+		Latitude  float64
+		Longitude float64
+	}
+
+	geo := &GeoLocation{Latitude: 48.8566, Longitude: 2.3522}
+
+	// Using PointerToOrNil for conditional pointer creation
+	latPtr := PointerToOrNil(geo.Latitude, geo != nil && geo.Latitude != 0)
+
+	if latPtr != nil {
+		println(*latPtr) // 48.8566
+	}
+}
+
+func ExamplePointerToIf() {
+	// Validate latitude is in valid range
+	isValidLatitude := func(lat float64) bool {
+		return lat >= -90 && lat <= 90
+	}
+
+	validLat := PointerToIf(48.8566, isValidLatitude) // returns pointer
+	invalidLat := PointerToIf(200.0, isValidLatitude) // returns nil
+
+	println(validLat != nil)   // true
+	println(invalidLat != nil) // false
+}
+
+func ExamplePointerToIfNonZero() {
+	// Simple non-zero check
+	name := PointerToIfNonZero("John") // returns pointer to "John"
+	empty := PointerToIfNonZero("")    // returns nil
+	count := PointerToIfNonZero(5)     // returns pointer to 5
+	zero := PointerToIfNonZero(0)      // returns nil
+
+	println(name != nil)  // true
+	println(empty != nil) // false
+	println(count != nil) // true
+	println(zero != nil)  // false
+}