Initial QSfera import

Server/vendor/github.com/olekukonko/tablewriter/tw/slicer.go

@@ -0,0 +1,134 @@
+package tw
+
+import "slices"
+
+// Slicer is a generic slice type that provides additional methods for slice manipulation.
+type Slicer[T any] []T
+
+// NewSlicer creates and returns a new initialized Slicer.
+func NewSlicer[T any]() Slicer[T] {
+	return make(Slicer[T], 0)
+}
+
+// Get returns the element at the specified index.
+// Returns the zero value if the index is out of bounds or the slice is nil.
+func (s Slicer[T]) Get(index int) T {
+	if s == nil || index < 0 || index >= len(s) {
+		var zero T
+		return zero
+	}
+	return s[index]
+}
+
+// GetOK returns the element at the specified index and a boolean indicating whether the index was valid.
+func (s Slicer[T]) GetOK(index int) (T, bool) {
+	if s == nil || index < 0 || index >= len(s) {
+		var zero T
+		return zero, false
+	}
+	return s[index], true
+}
+
+// Append appends elements to the slice and returns the new slice.
+func (s Slicer[T]) Append(elements ...T) Slicer[T] {
+	return append(s, elements...)
+}
+
+// Prepend adds elements to the beginning of the slice and returns the new slice.
+func (s Slicer[T]) Prepend(elements ...T) Slicer[T] {
+	return append(elements, s...)
+}
+
+// Len returns the number of elements in the slice.
+// Returns 0 if the slice is nil.
+func (s Slicer[T]) Len() int {
+	if s == nil {
+		return 0
+	}
+	return len(s)
+}
+
+// IsEmpty returns true if the slice is nil or has zero elements.
+func (s Slicer[T]) IsEmpty() bool {
+	return s.Len() == 0
+}
+
+// Has returns true if the index exists in the slice.
+func (s Slicer[T]) Has(index int) bool {
+	return index >= 0 && index < s.Len()
+}
+
+// First returns the first element of the slice, or the zero value if empty.
+func (s Slicer[T]) First() T {
+	return s.Get(0)
+}
+
+// Last returns the last element of the slice, or the zero value if empty.
+func (s Slicer[T]) Last() T {
+	return s.Get(s.Len() - 1)
+}
+
+// Each iterates over each element in the slice and calls the provided function.
+// Does nothing if the slice is nil.
+func (s Slicer[T]) Each(fn func(T)) {
+	for _, v := range s {
+		fn(v)
+	}
+}
+
+// Filter returns a new Slicer containing only elements that satisfy the predicate.
+func (s Slicer[T]) Filter(fn func(T) bool) Slicer[T] {
+	result := NewSlicer[T]()
+	for _, v := range s {
+		if fn(v) {
+			result = result.Append(v)
+		}
+	}
+	return result
+}
+
+// Map returns a new Slicer with each element transformed by the provided function.
+func (s Slicer[T]) Map(fn func(T) T) Slicer[T] {
+	result := NewSlicer[T]()
+	for _, v := range s {
+		result = result.Append(fn(v))
+	}
+	return result
+}
+
+// Contains returns true if the slice contains an element that satisfies the predicate.
+func (s Slicer[T]) Contains(fn func(T) bool) bool {
+	return slices.ContainsFunc(s, fn)
+}
+
+// Find returns the first element that satisfies the predicate, along with a boolean indicating if it was found.
+func (s Slicer[T]) Find(fn func(T) bool) (T, bool) {
+	for _, v := range s {
+		if fn(v) {
+			return v, true
+		}
+	}
+	var zero T
+	return zero, false
+}
+
+// Clone returns a shallow copy of the Slicer.
+func (s Slicer[T]) Clone() Slicer[T] {
+	result := NewSlicer[T]()
+	if s != nil {
+		result = append(result, s...)
+	}
+	return result
+}
+
+// SlicerToMapper converts a Slicer of KeyValuePair to a Mapper.
+func SlicerToMapper[K comparable, V any](s Slicer[KeyValuePair[K, V]]) Mapper[K, V] {
+	result := make(Mapper[K, V])
+	if s == nil {
+		return result
+	}
+	for _, pair := range s {
+		result[pair.Key] = pair.Value
+	}
+	return result
+}