remove ginext/mongoext (no-dep lib)

langext/array.go

@@ -0,0 +1,134 @@
+package langext
+
+import (
+	"reflect"
+)
+
+func ForceArray[T any](v []T) []T {
+	if v == nil {
+		return make([]T, 0)
+	} else {
+		return v
+	}
+}
+
+func ReverseArray[T any](v []T) {
+	for i, j := 0, len(v)-1; i < j; i, j = i+1, j-1 {
+		v[i], v[j] = v[j], v[i]
+	}
+}
+
+func InArray[T comparable](needle T, haystack []T) bool {
+	for _, v := range haystack {
+		if v == needle {
+			return true
+		}
+	}
+	return false
+}
+
+func ArrUnique[T comparable](array []T) []T {
+	m := make(map[T]bool, len(array))
+	for _, v := range array {
+		m[v] = true
+	}
+	result := make([]T, 0, len(m))
+	for v := range m {
+		result = append(result, v)
+	}
+	return result
+}
+
+func ArrEqualsExact[T comparable](arr1 []T, arr2 []T) bool {
+	if len(arr1) != len(arr2) {
+		return false
+	}
+
+	for i := range arr1 {
+		if arr1[i] != arr2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func ArrAll(arr interface{}, fn func(int) bool) bool {
+	av := reflect.ValueOf(arr)
+	for i := 0; i < av.Len(); i++ {
+		if !fn(i) {
+			return false
+		}
+	}
+	return true
+}
+
+func ArrAllErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
+	av := reflect.ValueOf(arr)
+	for i := 0; i < av.Len(); i++ {
+		v, err := fn(i)
+		if err != nil {
+			return false, err
+		}
+		if !v {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+func ArrNone(arr interface{}, fn func(int) bool) bool {
+	av := reflect.ValueOf(arr)
+	for i := 0; i < av.Len(); i++ {
+		if fn(i) {
+			return false
+		}
+	}
+	return true
+}
+
+func ArrNoneErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
+	av := reflect.ValueOf(arr)
+	for i := 0; i < av.Len(); i++ {
+		v, err := fn(i)
+		if err != nil {
+			return false, err
+		}
+		if v {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+func ArrAny(arr interface{}, fn func(int) bool) bool {
+	av := reflect.ValueOf(arr)
+	for i := 0; i < av.Len(); i++ {
+		if fn(i) {
+			return true
+		}
+	}
+	return false
+}
+
+func ArrAnyErr(arr interface{}, fn func(int) (bool, error)) (bool, error) {
+	av := reflect.ValueOf(arr)
+	for i := 0; i < av.Len(); i++ {
+		v, err := fn(i)
+		if err != nil {
+			return false, err
+		}
+		if v {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func AddToSet[T comparable](set []T, add T) []T {
+	for _, v := range set {
+		if v == add {
+			return set
+		}
+	}
+	return append(set, add)
+}

langext/bytes.go

@@ -0,0 +1,16 @@
+package langext
+
+import "fmt"
+
+func FormatBytesToSI(b uint64) string {
+	const unit = 1000
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := uint64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "kMGTPE"[exp])
+}

langext/coalesce.go

@@ -0,0 +1,62 @@
+package langext
+
+import (
+	"fmt"
+	"time"
+)
+
+func Coalesce[T any](v *T, def T) T {
+	if v == nil {
+		return def
+	} else {
+		return *v
+	}
+}
+
+func CoalesceString(s *string, def string) string {
+	if s == nil {
+		return def
+	} else {
+		return *s
+	}
+}
+
+func CoalesceInt(i *int, def int) int {
+	if i == nil {
+		return def
+	} else {
+		return *i
+	}
+}
+
+func CoalesceInt32(i *int32, def int32) int32 {
+	if i == nil {
+		return def
+	} else {
+		return *i
+	}
+}
+
+func CoalesceBool(b *bool, def bool) bool {
+	if b == nil {
+		return def
+	} else {
+		return *b
+	}
+}
+
+func CoalesceTime(t *time.Time, def time.Time) time.Time {
+	if t == nil {
+		return def
+	} else {
+		return *t
+	}
+}
+
+func CoalesceStringer(s fmt.Stringer, def string) string {
+	if IsNil(s) {
+		return def
+	} else {
+		return s.String()
+	}
+}

langext/compare.go

@@ -0,0 +1,32 @@
+package langext
+
+func CompareIntArr(arr1 []int, arr2 []int) bool {
+
+	for i := 0; i < len(arr1) || i < len(arr2); i++ {
+
+		if i < len(arr1) && i < len(arr2) {
+
+			if arr1[i] < arr2[i] {
+				return true
+			} else if arr1[i] > arr2[i] {
+				return false
+			} else {
+				continue
+			}
+
+		}
+
+		if i < len(arr1) {
+
+			return true
+
+		} else { // if i < len(arr2)
+
+			return false
+
+		}
+
+	}
+
+	return false
+}

langext/pointer.go

@@ -0,0 +1,36 @@
+package langext
+
+import (
+	"reflect"
+)
+
+func Ptr[T any](v T) *T {
+	return &v
+}
+
+func PtrInt32(v int32) *int32 {
+	return &v
+}
+
+func PtrInt64(v int64) *int64 {
+	return &v
+}
+
+func PtrFloat32(v float32) *float32 {
+	return &v
+}
+
+func PtrFloat64(v float64) *float64 {
+	return &v
+}
+
+func IsNil(i interface{}) bool {
+	if i == nil {
+		return true
+	}
+	switch reflect.TypeOf(i).Kind() {
+	case reflect.Ptr, reflect.Map, reflect.Array, reflect.Chan, reflect.Slice:
+		return reflect.ValueOf(i).IsNil()
+	}
+	return false
+}

langext/string.go

@@ -0,0 +1,63 @@
+package langext
+
+import (
+	"fmt"
+	"strings"
+)
+
+func StrLimit(val string, maxlen int, suffix string) string {
+	if len(val) > maxlen {
+		return val[0:maxlen-len(suffix)] + suffix
+	}
+	return val
+}
+
+func StrSplit(val string, sep string, allowEmpty bool) []string {
+	var arr []string
+	for _, k := range strings.Split(val, sep) {
+		if allowEmpty || k != "" {
+			arr = append(arr, k)
+		}
+	}
+	return arr
+}
+
+func StrPadRight(str string, pad string, padlen int) string {
+	if pad == "" {
+		pad = " "
+	}
+
+	if len(str) >= padlen {
+		return str
+	}
+
+	return str + strings.Repeat(pad, padlen-len(str))[0:(padlen-len(str))]
+}
+
+func StrPadLeft(str string, pad string, padlen int) string {
+	if pad == "" {
+		pad = " "
+	}
+
+	if len(str) >= padlen {
+		return str
+	}
+
+	return strings.Repeat(pad, padlen-len(str))[0:(padlen-len(str))] + str
+}
+
+func DeRefStringer(v fmt.Stringer) *string {
+	if v == nil {
+		return nil
+	} else {
+		return Ptr(v.String())
+	}
+}
+
+func ConvertStringerArray[T fmt.Stringer](inarr []T) []string {
+	result := make([]string, 0, len(inarr))
+	for _, v := range inarr {
+		result = append(result, v.String())
+	}
+	return result
+}