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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
package split
import (
"strconv"
"time"
"unsafe"
"codeberg.org/gruf/go-bytesize"
)
// Signed defines a signed
// integer generic type parameter.
type Signed interface {
~int | ~int8 | ~int16 | ~int32 | ~int64
}
// Unsigned defines an unsigned
// integer generic type paramter.
type Unsigned interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
// Float defines a float-type generic parameter.
type Float interface{ ~float32 | ~float64 }
// SplitFunc will split input string on commas, taking into account string quoting
// and stripping extra whitespace, passing each split to the given function hook.
func SplitFunc(str string, fn func(string) error) error {
return (&Splitter{}).SplitFunc(str, fn)
}
// SplitStrings will pass string input to SplitFunc(), compiling a slice of strings.
func SplitStrings[String ~string](str string) ([]String, error) {
var slice []String
// Simply append each split string to slice
if err := SplitFunc(str, func(s string) error {
slice = append(slice, String(s))
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
// SplitBools will pass string input to SplitFunc(), parsing and compiling a slice of bools.
func SplitBools[Bool ~bool](str string) ([]Bool, error) {
var slice []Bool
// Parse each bool split from input string
if err := SplitFunc(str, func(s string) error {
b, err := strconv.ParseBool(s)
if err != nil {
return err
}
slice = append(slice, Bool(b))
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
// SplitInts will pass string input to SplitFunc(), parsing and compiling a slice of signed integers.
func SplitInts[Int Signed](str string) ([]Int, error) {
// Determine bits from param type size
bits := int(unsafe.Sizeof(Int(0)) * 8)
var slice []Int
// Parse each int split from input string
if err := SplitFunc(str, func(s string) error {
i, err := strconv.ParseInt(s, 10, bits)
if err != nil {
return err
}
slice = append(slice, Int(i))
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
// SplitUints will pass string input to SplitFunc(), parsing and compiling a slice of unsigned integers.
func SplitUints[Uint Unsigned](str string) ([]Uint, error) {
// Determine bits from param type size
bits := int(unsafe.Sizeof(Uint(0)) * 8)
var slice []Uint
// Parse each uint split from input string
if err := SplitFunc(str, func(s string) error {
u, err := strconv.ParseUint(s, 10, bits)
if err != nil {
return err
}
slice = append(slice, Uint(u))
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
// SplitFloats will pass string input to SplitFunc(), parsing and compiling a slice of floats.
func SplitFloats[Float_ Float](str string) ([]Float_, error) {
// Determine bits from param type size
bits := int(unsafe.Sizeof(Float_(0)) * 8)
var slice []Float_
// Parse each float split from input string
if err := SplitFunc(str, func(s string) error {
f, err := strconv.ParseFloat(s, bits)
if err != nil {
return err
}
slice = append(slice, Float_(f))
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
// SplitSizes will pass string input to SplitFunc(), parsing and compiling a slice of byte sizes.
func SplitSizes(str string) ([]bytesize.Size, error) {
var slice []bytesize.Size
// Parse each size split from input string
if err := SplitFunc(str, func(s string) error {
sz, err := bytesize.ParseSize(s)
if err != nil {
return err
}
slice = append(slice, sz)
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
// SplitDurations will pass string input to SplitFunc(), parsing and compiling a slice of durations.
func SplitDurations(str string) ([]time.Duration, error) {
var slice []time.Duration
// Parse each duration split from input string
if err := SplitFunc(str, func(s string) error {
d, err := time.ParseDuration(s)
if err != nil {
return err
}
slice = append(slice, d)
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
// SplitTimes will pass string input to SplitFunc(), parsing and compiling a slice of times.
func SplitTimes(str string, format string) ([]time.Time, error) {
var slice []time.Time
// Parse each time split from input string
if err := SplitFunc(str, func(s string) error {
t, err := time.Parse(s, format)
if err != nil {
return err
}
slice = append(slice, t)
return nil
}); err != nil {
return nil, err
}
return slice, nil
}
|
