From bc96113434ea51e4a3b7215a275d83099228e481 Mon Sep 17 00:00:00 2001 From: acabarbaye Date: Mon, 16 Dec 2024 15:19:34 +0000 Subject: [PATCH] :sparkles: [fields] Extends utilities with regards to optional fields --- changes/20241216151002.feature | 1 + utils/field/fields.go | 136 ++++++++++++++++----------------- utils/field/fields_test.go | 21 +++++ 3 files changed, 87 insertions(+), 71 deletions(-) create mode 100644 changes/20241216151002.feature diff --git a/changes/20241216151002.feature b/changes/20241216151002.feature new file mode 100644 index 0000000000..3602ca9786 --- /dev/null +++ b/changes/20241216151002.feature @@ -0,0 +1 @@ +:sparkles: [fields] Extends utilities with regards to optional fields diff --git a/utils/field/fields.go b/utils/field/fields.go index 47767ab5d1..3772063f34 100644 --- a/utils/field/fields.go +++ b/utils/field/fields.go @@ -9,172 +9,166 @@ package field import "time" // ToOptionalInt returns a pointer to an int -func ToOptionalInt(i int) *int { - return &i +func ToOptionalInt(f int) *int { + return ToOptional(f) } // OptionalInt returns the value of an optional field or else // returns defaultValue. func OptionalInt(ptr *int, defaultValue int) int { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalInt32 returns a pointer to an int32. -func ToOptionalInt32(i int32) *int32 { - return &i +func ToOptionalInt32(f int32) *int32 { + return ToOptional(f) } // OptionalInt32 returns the value of an optional field or else // returns defaultValue. func OptionalInt32(ptr *int32, defaultValue int32) int32 { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalUint returns a pointer to an uint -func ToOptionalUint(i uint) *uint { - return &i +func ToOptionalUint(f uint) *uint { + return ToOptional(f) } // OptionalUint returns the value of an optional field or else returns defaultValue. func OptionalUint(ptr *uint, defaultValue uint) uint { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalUint32 returns a pointer to an uint32. -func ToOptionalUint32(i uint32) *uint32 { - return &i +func ToOptionalUint32(f uint32) *uint32 { + return ToOptional(f) } // OptionalUint32 returns the value of an optional field or else returns defaultValue. func OptionalUint32(ptr *uint32, defaultValue uint32) uint32 { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalInt64 returns a pointer to an int64. -func ToOptionalInt64(i int64) *int64 { - return &i +func ToOptionalInt64(f int64) *int64 { + return ToOptional(f) } // OptionalInt64 returns the value of an optional field or else returns defaultValue. func OptionalInt64(ptr *int64, defaultValue int64) int64 { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalUint64 returns a pointer to an uint64. -func ToOptionalUint64(i uint64) *uint64 { - return &i +func ToOptionalUint64(f uint64) *uint64 { + return ToOptional(f) } // OptionalUint64 returns the value of an optional field or else returns defaultValue. func OptionalUint64(ptr *uint64, defaultValue uint64) uint64 { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalBool returns a pointer to a bool. func ToOptionalBool(b bool) *bool { - return &b + return ToOptional(b) } // OptionalBool returns the value of an optional field or else returns defaultValue. func OptionalBool(ptr *bool, defaultValue bool) bool { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalString returns a pointer to a string. func ToOptionalString(s string) *string { - return &s + return ToOptional(s) } // OptionalString returns the value of an optional field or else returns defaultValue. func OptionalString(ptr *string, defaultValue string) string { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalAny returns a pointer to a object. func ToOptionalAny(a any) *any { - return &a + return ToOptional(a) } // OptionalAny returns the value of an optional field or else returns defaultValue. func OptionalAny(ptr *any, defaultValue any) any { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalFloat32 returns a pointer to a float32. -func ToOptionalFloat32(i float32) *float32 { - return &i +func ToOptionalFloat32(f float32) *float32 { + return ToOptional(f) } // OptionalFloat32 returns the value of an optional field or else returns defaultValue. func OptionalFloat32(ptr *float32, defaultValue float32) float32 { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalFloat64 returns a pointer to a float64. -func ToOptionalFloat64(i float64) *float64 { - return &i +func ToOptionalFloat64(f float64) *float64 { + return ToOptional(f) } // OptionalFloat64 returns the value of an optional field or else returns defaultValue. func OptionalFloat64(ptr *float64, defaultValue float64) float64 { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalDuration returns a pointer to a Duration. -func ToOptionalDuration(i time.Duration) *time.Duration { - return &i +func ToOptionalDuration(f time.Duration) *time.Duration { + return ToOptional(f) } // OptionalDuration returns the value of an optional field or else returns defaultValue. func OptionalDuration(ptr *time.Duration, defaultValue time.Duration) time.Duration { - if ptr != nil { - return *ptr - } - return defaultValue + return Optional(ptr, defaultValue) } // ToOptionalTime returns a pointer to a Time. -func ToOptionalTime(i time.Time) *time.Time { - return &i +func ToOptionalTime(f time.Time) *time.Time { + return ToOptional(f) } // OptionalTime returns the value of an optional field or else returns defaultValue. func OptionalTime(ptr *time.Time, defaultValue time.Time) time.Time { + return Optional(ptr, defaultValue) +} + +// ToOptional returns a pointer to the given field value. +func ToOptional[T any](v T) *T { + return &v +} + +// Optional returns the value of an optional field or else returns defaultValue. +func Optional[T any](ptr *T, defaultValue T) T { if ptr != nil { return *ptr } return defaultValue } + +// Equal returns true if both arguments are nil or both arguments +// dereference to the same value. +func Equal[T comparable](a, b *T) bool { + if (a == nil) != (b == nil) { + return false + } + if a == nil { + return true + } + return EqualValue(a, *b) +} + +// EqualValue returns true if optional field dereferences to the value. +func EqualValue[T comparable](field *T, value T) bool { + if field == nil { + return false + } + return *field == value +} diff --git a/utils/field/fields_test.go b/utils/field/fields_test.go index 805875a490..49a03ea6ba 100644 --- a/utils/field/fields_test.go +++ b/utils/field/fields_test.go @@ -228,3 +228,24 @@ func TestOptionalField(t *testing.T) { }) } } + +func TestEqual(t *testing.T) { + type T int + assert.True(t, Equal[T](nil, nil)) + assert.False(t, Equal(ToOptionalInt(1), nil)) + assert.False(t, Equal(nil, ToOptionalInt(1))) + assert.True(t, Equal(ToOptionalInt(1), ToOptionalInt(1))) + str := faker.Sentence() + assert.True(t, Equal(ToOptionalString(str), ToOptionalString(str))) + assert.False(t, Equal(ToOptionalString(str), ToOptionalString(""))) +} + +func TestEqualValue(t *testing.T) { + type T any + assert.False(t, EqualValue[T](nil, nil)) + assert.False(t, EqualValue(nil, 1)) + assert.True(t, EqualValue(ToOptionalInt(1), 1)) + str := faker.Sentence() + assert.True(t, EqualValue(ToOptionalString(str), str)) + assert.False(t, EqualValue(ToOptionalString(str), "")) +}