Initial QSfera import

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

@@ -0,0 +1,245 @@
+package tw
+
+import (
+	"fmt"
+	"sort"
+)
+
+// KeyValuePair represents a single key-value pair from a Mapper.
+type KeyValuePair[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// Mapper is a generic map type with comparable keys and any value type.
+// It provides type-safe operations on maps with additional convenience methods.
+type Mapper[K comparable, V any] map[K]V
+
+// NewMapper creates and returns a new initialized Mapper.
+func NewMapper[K comparable, V any]() Mapper[K, V] {
+	return make(Mapper[K, V])
+}
+
+// Get returns the value associated with the key.
+// If the key doesn't exist or the map is nil, it returns the zero value for the value type.
+func (m Mapper[K, V]) Get(key K) V {
+	if m == nil {
+		var zero V
+		return zero
+	}
+	return m[key]
+}
+
+// OK returns the value associated with the key and a boolean indicating whether the key exists.
+func (m Mapper[K, V]) OK(key K) (V, bool) {
+	if m == nil {
+		var zero V
+		return zero, false
+	}
+	val, ok := m[key]
+	return val, ok
+}
+
+// Set sets the value for the specified key.
+// Does nothing if the map is nil.
+func (m Mapper[K, V]) Set(key K, value V) Mapper[K, V] {
+	if m != nil {
+		m[key] = value
+	}
+	return m
+}
+
+// Delete removes the specified key from the map.
+// Does nothing if the key doesn't exist or the map is nil.
+func (m Mapper[K, V]) Delete(key K) Mapper[K, V] {
+	if m != nil {
+		delete(m, key)
+	}
+	return m
+}
+
+// Has returns true if the key exists in the map, false otherwise.
+func (m Mapper[K, V]) Has(key K) bool {
+	if m == nil {
+		return false
+	}
+	_, exists := m[key]
+	return exists
+}
+
+// Len returns the number of elements in the map.
+// Returns 0 if the map is nil.
+func (m Mapper[K, V]) Len() int {
+	if m == nil {
+		return 0
+	}
+	return len(m)
+}
+
+// Keys returns a slice containing all keys in the map.
+// Returns nil if the map is nil or empty.
+func (m Mapper[K, V]) Keys() []K {
+	if m == nil {
+		return nil
+	}
+	keys := make([]K, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	return keys
+}
+
+func (m Mapper[K, V]) Clear() {
+	if m == nil {
+		return
+	}
+	for k := range m {
+		delete(m, k)
+	}
+}
+
+// Values returns a slice containing all values in the map.
+// Returns nil if the map is nil or empty.
+func (m Mapper[K, V]) Values() []V {
+	if m == nil {
+		return nil
+	}
+	values := make([]V, 0, len(m))
+	for _, v := range m {
+		values = append(values, v)
+	}
+	return values
+}
+
+// Each iterates over each key-value pair in the map and calls the provided function.
+// Does nothing if the map is nil.
+func (m Mapper[K, V]) Each(fn func(K, V)) {
+	for k, v := range m {
+		fn(k, v)
+	}
+}
+
+// Filter returns a new Mapper containing only the key-value pairs that satisfy the predicate.
+func (m Mapper[K, V]) Filter(fn func(K, V) bool) Mapper[K, V] {
+	result := NewMapper[K, V]()
+	for k, v := range m {
+		if fn(k, v) {
+			result[k] = v
+		}
+	}
+	return result
+}
+
+// MapValues returns a new Mapper with the same keys but values transformed by the provided function.
+func (m Mapper[K, V]) MapValues(fn func(V) V) Mapper[K, V] {
+	result := NewMapper[K, V]()
+	for k, v := range m {
+		result[k] = fn(v)
+	}
+	return result
+}
+
+// Clone returns a shallow copy of the Mapper.
+func (m Mapper[K, V]) Clone() Mapper[K, V] {
+	result := NewMapper[K, V]()
+	for k, v := range m {
+		result[k] = v
+	}
+	return result
+}
+
+// Slicer converts the Mapper to a Slicer of key-value pairs.
+func (m Mapper[K, V]) Slicer() Slicer[KeyValuePair[K, V]] {
+	if m == nil {
+		return nil
+	}
+	result := make(Slicer[KeyValuePair[K, V]], 0, len(m))
+	for k, v := range m {
+		result = append(result, KeyValuePair[K, V]{Key: k, Value: v})
+	}
+	return result
+}
+
+func (m Mapper[K, V]) SortedKeys() []K {
+	keys := make([]K, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+
+	sort.Slice(keys, func(i, j int) bool {
+		a, b := any(keys[i]), any(keys[j])
+
+		switch va := a.(type) {
+		case int:
+			if vb, ok := b.(int); ok {
+				return va < vb
+			}
+		case int32:
+			if vb, ok := b.(int32); ok {
+				return va < vb
+			}
+		case int64:
+			if vb, ok := b.(int64); ok {
+				return va < vb
+			}
+		case uint:
+			if vb, ok := b.(uint); ok {
+				return va < vb
+			}
+		case uint64:
+			if vb, ok := b.(uint64); ok {
+				return va < vb
+			}
+		case float32:
+			if vb, ok := b.(float32); ok {
+				return va < vb
+			}
+		case float64:
+			if vb, ok := b.(float64); ok {
+				return va < vb
+			}
+		case string:
+			if vb, ok := b.(string); ok {
+				return va < vb
+			}
+		}
+
+		// fallback to string comparison
+		return fmt.Sprintf("%v", a) < fmt.Sprintf("%v", b)
+	})
+
+	return keys
+}
+
+func NewBoolMapper[K comparable](keys ...K) Mapper[K, bool] {
+	if len(keys) == 0 {
+		return nil
+	}
+	mapper := NewMapper[K, bool]()
+	for _, key := range keys {
+		mapper.Set(key, true)
+	}
+	return mapper
+}
+
+func NewIntMapper[K comparable](keys ...K) Mapper[K, int] {
+	if len(keys) == 0 {
+		return nil
+	}
+	mapper := NewMapper[K, int]()
+	for _, key := range keys {
+		mapper.Set(key, 0)
+	}
+	return mapper
+}
+
+func NewIdentityMapper[K comparable](keys ...K) Mapper[K, K] {
+	if len(keys) == 0 {
+		return nil
+	}
+	mapper := NewMapper[K, K]()
+	for _, key := range keys {
+		mapper.Set(key, key)
+	}
+	return mapper
+}