Initial QSfera import

Server/vendor/github.com/gookit/goutil/conv.go

@@ -0,0 +1,231 @@
+package goutil
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+
+	"github.com/gookit/goutil/comdef"
+	"github.com/gookit/goutil/internal/comfunc"
+	"github.com/gookit/goutil/mathutil"
+	"github.com/gookit/goutil/reflects"
+	"github.com/gookit/goutil/strutil"
+)
+
+// Bool convert value to bool
+func Bool(v any) bool {
+	bl, _ := comfunc.ToBool(v)
+	return bl
+}
+
+// ToBool try to convert type to bool
+func ToBool(v any) (bool, error) { return comfunc.ToBool(v) }
+
+// String func. always converts value to string, will ignore error
+func String(v any) string {
+	s, _ := strutil.AnyToString(v, false)
+	return s
+}
+
+// ToString convert value to string, will return error on fail.
+func ToString(v any) (string, error) { return strutil.AnyToString(v, true) }
+
+// Int convert value to int
+func Int(v any) int {
+	iv, _ := mathutil.ToInt(v)
+	return iv
+}
+
+// ToInt try to convert value to int
+func ToInt(v any) (int, error) { return mathutil.ToInt(v) }
+
+// Int64 convert value to int64
+func Int64(v any) int64 {
+	iv, _ := mathutil.ToInt64(v)
+	return iv
+}
+
+// ToInt64 try to convert value to int64
+func ToInt64(v any) (int64, error) { return mathutil.ToInt64(v) }
+
+// Uint convert value to uint
+func Uint(v any) uint {
+	iv, _ := mathutil.ToUint(v)
+	return iv
+}
+
+// ToUint try to convert value to uint
+func ToUint(v any) (uint, error) { return mathutil.ToUint(v) }
+
+// Uint64 convert value to uint64
+func Uint64(v any) uint64 {
+	iv, _ := mathutil.ToUint64(v)
+	return iv
+}
+
+// ToUint64 try to convert value to uint64
+func ToUint64(v any) (uint64, error) { return mathutil.ToUint64(v) }
+
+// BoolString convert bool to string
+func BoolString(bl bool) string { return strconv.FormatBool(bl) }
+
+// BaseTypeVal convert custom type or intX,uintX,floatX to generic base type.
+//
+//	intX 	    => int64
+//	unitX 	    => uint64
+//	floatX      => float64
+//	string 	    => string
+//
+// returns int64,uint64,string,float or error
+func BaseTypeVal(val any) (value any, err error) {
+	return reflects.BaseTypeVal(reflect.ValueOf(val))
+}
+
+// SafeKind convert input any value to given reflect.Kind type.
+func SafeKind(val any, kind reflect.Kind) (newVal any) {
+	newVal, _ = ToKind(val, kind, nil)
+	return
+}
+
+// SafeConv convert input any value to given reflect.Kind type.
+func SafeConv(val any, kind reflect.Kind) (newVal any) {
+	newVal, _ = ToKind(val, kind, nil)
+	return
+}
+
+// ConvTo convert input any value to given reflect.Kind.
+func ConvTo(val any, kind reflect.Kind) (newVal any, err error) {
+	return ToKind(val, kind, nil)
+}
+
+// ConvOrDefault convert input any value to given reflect.Kind.
+// if fail will return default value.
+func ConvOrDefault(val any, kind reflect.Kind, defVal any) any {
+	newVal, err := ToKind(val, kind, nil)
+	if err != nil {
+		return defVal
+	}
+	return newVal
+}
+
+// ToType
+// func ToType[T any](val any, kind reflect.Kind, fbFunc func(val any) (T, error)) (newVal T, err error)  {
+// 	switch typVal.(type) { // assert ERROR
+// 	case string:
+// 	}
+// }
+
+// ToKind convert input any value to given reflect.Kind type.
+//
+// TIPs: Only support kind: string, bool, intX, uintX, floatX
+//
+// Examples:
+//
+//	val, err := ToKind("123", reflect.Int) // 123
+func ToKind(val any, kind reflect.Kind, fbFunc func(val any) (any, error)) (newVal any, err error) {
+	switch kind {
+	case reflect.Int:
+		var dstV int
+		if dstV, err = mathutil.ToInt(val); err == nil {
+			if dstV > math.MaxInt {
+				return nil, fmt.Errorf("value overflow int. val: %v", val)
+			}
+			newVal = dstV
+		}
+	case reflect.Int8:
+		var dstV int
+		if dstV, err = mathutil.ToInt(val); err == nil {
+			if dstV > math.MaxInt8 {
+				return nil, fmt.Errorf("value overflow int8. val: %v", val)
+			}
+			newVal = int8(dstV)
+		}
+	case reflect.Int16:
+		var dstV int
+		if dstV, err = mathutil.ToInt(val); err == nil {
+			if dstV > math.MaxInt16 {
+				return nil, fmt.Errorf("value overflow int16. val: %v", val)
+			}
+			newVal = int16(dstV)
+		}
+	case reflect.Int32:
+		var dstV int
+		if dstV, err = mathutil.ToInt(val); err == nil {
+			if dstV > math.MaxInt32 {
+				return nil, fmt.Errorf("value overflow int32. val: %v", val)
+			}
+			newVal = int32(dstV)
+		}
+	case reflect.Int64:
+		var dstV int64
+		if dstV, err = mathutil.ToInt64(val); err == nil {
+			newVal = dstV
+		}
+	case reflect.Uint:
+		var dstV uint
+		if dstV, err = mathutil.ToUint(val); err == nil {
+			newVal = dstV
+		}
+	case reflect.Uint8:
+		var dstV uint
+		if dstV, err = mathutil.ToUint(val); err == nil {
+			if dstV > math.MaxUint8 {
+				return nil, fmt.Errorf("value overflow uint8. val: %v", val)
+			}
+			newVal = uint8(dstV)
+		}
+	case reflect.Uint16:
+		var dstV uint
+		if dstV, err = mathutil.ToUint(val); err == nil {
+			if dstV > math.MaxUint16 {
+				return nil, fmt.Errorf("value overflow uint16. val: %v", val)
+			}
+			newVal = uint16(dstV)
+		}
+	case reflect.Uint32:
+		var dstV uint
+		if dstV, err = mathutil.ToUint(val); err == nil {
+			if dstV > math.MaxUint32 {
+				return nil, fmt.Errorf("value overflow uint32. val: %v", val)
+			}
+			newVal = uint32(dstV)
+		}
+	case reflect.Uint64:
+		var dstV uint64
+		if dstV, err = mathutil.ToUint64(val); err == nil {
+			newVal = dstV
+		}
+	case reflect.Float32:
+		var dstV float64
+		if dstV, err = mathutil.ToFloat(val); err == nil {
+			if dstV > math.MaxFloat32 {
+				return nil, fmt.Errorf("value overflow float32. val: %v", val)
+			}
+			newVal = float32(dstV)
+		}
+	case reflect.Float64:
+		var dstV float64
+		if dstV, err = mathutil.ToFloat(val); err == nil {
+			newVal = dstV
+		}
+	case reflect.String:
+		var dstV string
+		if dstV, err = strutil.ToString(val); err == nil {
+			newVal = dstV
+		}
+	case reflect.Bool:
+		if bl, err1 := comfunc.ToBool(val); err1 == nil {
+			newVal = bl
+		} else {
+			err = err1
+		}
+	default:
+		if fbFunc != nil {
+			newVal, err = fbFunc(val)
+		} else {
+			err = comdef.ErrConvType
+		}
+	}
+	return
+}