1 files changed, 187 insertions, 0 deletions
diff --git a/vendor/codeberg.org/gruf/go-split/split.go b/vendor/codeberg.org/gruf/go-split/split.go
new file mode 100644
index 000000000..3f55d7bc6
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-split/split.go
@@ -0,0 +1,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
+}