-
Notifications
You must be signed in to change notification settings - Fork 1
/
value.go
109 lines (95 loc) · 2.45 KB
/
value.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package utils
// Pointer returns a pointer to the value passed in.
//
// v := 1 // type is int
// vp := Pointer(v) // type is *int, *vp = 1
// TypeOf(vp) // "*int"
func Pointer[T any](v T) *T {
return &v
}
// PointerWithDefault returns the pointer if it is not nil, or the default pointer.
//
// v := Pointer(1)
// dv := Pointer(2)
// PointerWithDefault(v, dv) // &1
// v = nil
// PointerWithDefault(v, dv) // &2
func PointerWithDefault[T any](v *T, defaultValue *T) *T {
if v != nil {
return v
}
return defaultValue
}
// Value returns the value of a pointer, or the zero value of the type if the pointer is nil.
//
// var p1 *string // nil
// var p2 *string = Pointer("hello")
// Value(p1) // ""
// Value(p2) // "hello"
func Value[T any](v *T) T {
if v != nil {
return *v
}
var zero T
return zero
}
// ValueWithDefault returns the value passed in if it is not nil, otherwise returns the default
// value.
//
// var p1 *string // nil
// var p2 *string = Pointer("hello")
// ValueWithDefault(p1, "default") // "default"
// ValueWithDefault(p2, "default") // "hello"
func ValueWithDefault[T any](val *T, defaultVal T) T {
if val == nil {
return defaultVal
}
return *val
}
// PointerToSlice converts a slice of values into a slice of pointers.
func PointerSlice[T any](src []T) []*T {
dest := make([]*T, len(src))
for i := 0; i < len(src); i++ {
dest[i] = &(src[i])
}
return dest
}
// ValueSlice converts a slice of pointers into a slice of values, and it'll
// set the value to the zero value of the type if the pointer is point to nil.
//
// s1 := []*string{Pointer("Hello"), nil, Pointer("World")}
// s2 := ValueSlice(s1)
// // ["Hello", "", "World"]
func ValueSlice[T any](src []*T) []T {
dest := make([]T, len(src))
for i := 0; i < len(src); i++ {
if src[i] != nil {
dest[i] = *src[i]
}
}
return dest
}
// PointerMap converts a map of values into a map of pointers.
func PointerMap[K comparable, V any](src map[K]V) map[K]*V {
dest := make(map[K]*V)
for k, val := range src {
v := val
dest[k] = &v
}
return dest
}
// ValueMap converts a map of pointers into a map of values, and it'll set the
// value to the zero value of the type if the pointer is point to nil.
//
// m1 := map[string]*int{ "a": Pointer(1), "b": nil, "c": Pointer(3) }
// m2 := ValueMap(m1)
// // [a:1, b:0, c:3]
func ValueMap[K comparable, V any](src map[K]*V) map[K]V {
dest := make(map[K]V)
for k, val := range src {
if val != nil {
dest[k] = *val
}
}
return dest
}