build(deps): bump github.com/gookit/config/v2 from 2.2.4 to 2.2.5
Bumps [github.com/gookit/config/v2](https://github.com/gookit/config) from 2.2.4 to 2.2.5. - [Release notes](https://github.com/gookit/config/releases) - [Commits](https://github.com/gookit/config/compare/v2.2.4...v2.2.5) --- updated-dependencies: - dependency-name: github.com/gookit/config/v2 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>
This commit is contained in:
dependabot[bot]
committed by
Ralf Haferkamp
Ralf Haferkamp
parent
2253096609
commit
81e000b987
+382
-259
@@ -3,11 +3,14 @@ package mathutil
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/gookit/goutil/comdef"
|
||||
"github.com/gookit/goutil/internal/checkfn"
|
||||
"github.com/gookit/goutil/internal/comfunc"
|
||||
)
|
||||
|
||||
// ToIntFunc convert value to int
|
||||
@@ -17,19 +20,76 @@ type ToIntFunc func(any) (int, error)
|
||||
type ToInt64Func func(any) (int64, error)
|
||||
|
||||
// ToUintFunc convert value to uint
|
||||
type ToUintFunc func(any) (uint64, error)
|
||||
type ToUintFunc func(any) (uint, error)
|
||||
|
||||
// ToUint64Func convert value to uint
|
||||
type ToUint64Func func(any) (uint64, error)
|
||||
|
||||
// ToFloatFunc convert value to float
|
||||
type ToFloatFunc func(any) (float64, error)
|
||||
|
||||
// ToTypeFunc convert value to defined type
|
||||
type ToTypeFunc[T any] func(any) (T, error)
|
||||
|
||||
// ConvOption convert options
|
||||
type ConvOption[T any] struct {
|
||||
// if ture: value is nil, will return convert error;
|
||||
// if false(default): value is nil, will convert to zero value
|
||||
NilAsFail bool
|
||||
// HandlePtr auto convert ptr type(int,float,string) value. eg: *int to int
|
||||
// - if true: will use real type try convert. default is false
|
||||
// - NOTE: current T type's ptr is default support.
|
||||
HandlePtr bool
|
||||
// set custom fallback convert func for not supported type.
|
||||
UserConvFn ToTypeFunc[T]
|
||||
}
|
||||
|
||||
// NewConvOption create a new ConvOption
|
||||
func NewConvOption[T any](optFns ...ConvOptionFn[T]) *ConvOption[T] {
|
||||
opt := &ConvOption[T]{}
|
||||
opt.WithOption(optFns...)
|
||||
return opt
|
||||
}
|
||||
|
||||
// WithOption set convert option
|
||||
func (opt *ConvOption[T]) WithOption(optFns ...ConvOptionFn[T]) {
|
||||
for _, fn := range optFns {
|
||||
if fn != nil {
|
||||
fn(opt)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ConvOptionFn convert option func
|
||||
type ConvOptionFn[T any] func(opt *ConvOption[T])
|
||||
|
||||
// WithNilAsFail set ConvOption.NilAsFail option
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// ToIntWithFunc(val, mathutil.WithNilAsFail[int])
|
||||
func WithNilAsFail[T any](opt *ConvOption[T]) {
|
||||
opt.NilAsFail = true
|
||||
}
|
||||
|
||||
// WithHandlePtr set ConvOption.HandlePtr option
|
||||
func WithHandlePtr[T any](opt *ConvOption[T]) {
|
||||
opt.HandlePtr = true
|
||||
}
|
||||
|
||||
// WithUserConvFn set ConvOption.UserConvFn option
|
||||
func WithUserConvFn[T any](fn ToTypeFunc[T]) ConvOptionFn[T] {
|
||||
return func(opt *ConvOption[T]) {
|
||||
opt.UserConvFn = fn
|
||||
}
|
||||
}
|
||||
|
||||
/*************************************************************
|
||||
* convert value to int
|
||||
*************************************************************/
|
||||
|
||||
// Int convert value to int
|
||||
func Int(in any) (int, error) {
|
||||
return ToInt(in)
|
||||
}
|
||||
func Int(in any) (int, error) { return ToInt(in) }
|
||||
|
||||
// SafeInt convert value to int, will ignore error
|
||||
func SafeInt(in any) int {
|
||||
@@ -38,12 +98,10 @@ func SafeInt(in any) int {
|
||||
}
|
||||
|
||||
// QuietInt convert value to int, will ignore error
|
||||
func QuietInt(in any) int {
|
||||
return SafeInt(in)
|
||||
}
|
||||
func QuietInt(in any) int { return SafeInt(in) }
|
||||
|
||||
// MustInt convert value to int, will panic on error
|
||||
func MustInt(in any) int {
|
||||
// IntOrPanic convert value to int, will panic on error
|
||||
func IntOrPanic(in any) int {
|
||||
val, err := ToInt(in)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
@@ -51,19 +109,15 @@ func MustInt(in any) int {
|
||||
return val
|
||||
}
|
||||
|
||||
// IntOrPanic convert value to int, will panic on error
|
||||
func IntOrPanic(in any) int {
|
||||
return MustInt(in)
|
||||
}
|
||||
// MustInt convert value to int, will panic on error
|
||||
func MustInt(in any) int { return IntOrPanic(in) }
|
||||
|
||||
// IntOrDefault convert value to int, return defaultVal on failed
|
||||
func IntOrDefault(in any, defVal int) int {
|
||||
return IntOr(in, defVal)
|
||||
}
|
||||
func IntOrDefault(in any, defVal int) int { return IntOr(in, defVal) }
|
||||
|
||||
// IntOr convert value to int, return defaultVal on failed
|
||||
func IntOr(in any, defVal int) int {
|
||||
val, err := ToIntWithFunc(in, nil)
|
||||
val, err := ToIntWith(in)
|
||||
if err != nil {
|
||||
return defVal
|
||||
}
|
||||
@@ -71,20 +125,28 @@ func IntOr(in any, defVal int) int {
|
||||
}
|
||||
|
||||
// IntOrErr convert value to int, return error on failed
|
||||
func IntOrErr(in any) (iVal int, err error) {
|
||||
return ToIntWithFunc(in, nil)
|
||||
}
|
||||
func IntOrErr(in any) (int, error) { return ToIntWith(in) }
|
||||
|
||||
// ToInt convert value to int, return error on failed
|
||||
func ToInt(in any) (iVal int, err error) {
|
||||
return ToIntWithFunc(in, nil)
|
||||
}
|
||||
func ToInt(in any) (int, error) { return ToIntWith(in) }
|
||||
|
||||
// ToIntWith convert value to int, can with some option func.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// ToIntWithFunc(val, mathutil.WithNilAsFail, mathutil.WithUserConvFn(func(in any) (int, error) {
|
||||
// })
|
||||
func ToIntWith(in any, optFns ...ConvOptionFn[int]) (iVal int, err error) {
|
||||
opt := NewConvOption[int](optFns...)
|
||||
if !opt.NilAsFail && in == nil {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// ToIntWithFunc convert value to int, will call usrFn on value type not supported.
|
||||
func ToIntWithFunc(in any, usrFn ToIntFunc) (iVal int, err error) {
|
||||
switch tVal := in.(type) {
|
||||
case int:
|
||||
iVal = tVal
|
||||
case *int: // default support int ptr type
|
||||
iVal = *tVal
|
||||
case int8:
|
||||
iVal = int(tVal)
|
||||
case int16:
|
||||
@@ -131,7 +193,7 @@ func ToIntWithFunc(in any, usrFn ToIntFunc) (iVal int, err error) {
|
||||
}
|
||||
case string:
|
||||
iVal, err = strconv.Atoi(strings.TrimSpace(tVal))
|
||||
case interface{ Int64() (int64, error) }: // eg: json.Number
|
||||
case comdef.Int64able: // eg: json.Number
|
||||
var i64 int64
|
||||
if i64, err = tVal.Int64(); err == nil {
|
||||
if i64 > math.MaxInt32 {
|
||||
@@ -141,11 +203,19 @@ func ToIntWithFunc(in any, usrFn ToIntFunc) (iVal int, err error) {
|
||||
}
|
||||
}
|
||||
default:
|
||||
if usrFn != nil {
|
||||
return usrFn(in)
|
||||
} else {
|
||||
err = comdef.ErrConvType
|
||||
if opt.HandlePtr {
|
||||
if rv := reflect.ValueOf(in); rv.Kind() == reflect.Pointer {
|
||||
rv = rv.Elem()
|
||||
if checkfn.IsSimpleKind(rv.Kind()) {
|
||||
return ToIntWith(rv.Interface(), optFns...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if opt.UserConvFn != nil {
|
||||
return opt.UserConvFn(in)
|
||||
}
|
||||
err = comdef.ErrConvType
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -165,29 +235,127 @@ func StrIntOr(s string, defVal int) int {
|
||||
return iVal
|
||||
}
|
||||
|
||||
/*************************************************************
|
||||
* convert value to int64
|
||||
*************************************************************/
|
||||
|
||||
// Int64 convert value to int64, return error on failed
|
||||
func Int64(in any) (int64, error) { return ToInt64(in) }
|
||||
|
||||
// SafeInt64 convert value to int64, will ignore error
|
||||
func SafeInt64(in any) int64 {
|
||||
i64, _ := ToInt64With(in)
|
||||
return i64
|
||||
}
|
||||
|
||||
// QuietInt64 convert value to int64, will ignore error
|
||||
func QuietInt64(in any) int64 { return SafeInt64(in) }
|
||||
|
||||
// MustInt64 convert value to int64, will panic on error
|
||||
func MustInt64(in any) int64 {
|
||||
i64, err := ToInt64With(in)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return i64
|
||||
}
|
||||
|
||||
// Int64OrDefault convert value to int64, return default val on failed
|
||||
func Int64OrDefault(in any, defVal int64) int64 { return Int64Or(in, defVal) }
|
||||
|
||||
// Int64Or convert value to int64, return default val on failed
|
||||
func Int64Or(in any, defVal int64) int64 {
|
||||
i64, err := ToInt64With(in)
|
||||
if err != nil {
|
||||
return defVal
|
||||
}
|
||||
return i64
|
||||
}
|
||||
|
||||
// ToInt64 convert value to int64, return error on failed
|
||||
func ToInt64(in any) (int64, error) { return ToInt64With(in) }
|
||||
|
||||
// Int64OrErr convert value to int64, return error on failed
|
||||
func Int64OrErr(in any) (int64, error) { return ToInt64With(in) }
|
||||
|
||||
// ToInt64With try to convert value to int64. can with some option func, more see ConvOption.
|
||||
func ToInt64With(in any, optFns ...ConvOptionFn[int64]) (i64 int64, err error) {
|
||||
opt := NewConvOption(optFns...)
|
||||
if !opt.NilAsFail && in == nil {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
switch tVal := in.(type) {
|
||||
case string:
|
||||
i64, err = strconv.ParseInt(strings.TrimSpace(tVal), 10, 0)
|
||||
case int:
|
||||
i64 = int64(tVal)
|
||||
case int8:
|
||||
i64 = int64(tVal)
|
||||
case int16:
|
||||
i64 = int64(tVal)
|
||||
case int32:
|
||||
i64 = int64(tVal)
|
||||
case int64:
|
||||
i64 = tVal
|
||||
case *int64: // default support int64 ptr type
|
||||
i64 = *tVal
|
||||
case uint:
|
||||
i64 = int64(tVal)
|
||||
case uint8:
|
||||
i64 = int64(tVal)
|
||||
case uint16:
|
||||
i64 = int64(tVal)
|
||||
case uint32:
|
||||
i64 = int64(tVal)
|
||||
case uint64:
|
||||
i64 = int64(tVal)
|
||||
case float32:
|
||||
i64 = int64(tVal)
|
||||
case float64:
|
||||
i64 = int64(tVal)
|
||||
case time.Duration:
|
||||
i64 = int64(tVal)
|
||||
case comdef.Int64able: // eg: json.Number
|
||||
i64, err = tVal.Int64()
|
||||
default:
|
||||
if opt.HandlePtr {
|
||||
if rv := reflect.ValueOf(in); rv.Kind() == reflect.Pointer {
|
||||
rv = rv.Elem()
|
||||
if checkfn.IsSimpleKind(rv.Kind()) {
|
||||
return ToInt64With(rv.Interface(), optFns...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if opt.UserConvFn != nil {
|
||||
i64, err = opt.UserConvFn(in)
|
||||
} else {
|
||||
err = comdef.ErrConvType
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
/*************************************************************
|
||||
* convert value to uint
|
||||
*************************************************************/
|
||||
|
||||
// Uint convert any to uint, return error on failed
|
||||
func Uint(in any) (uint64, error) {
|
||||
return ToUint(in)
|
||||
}
|
||||
func Uint(in any) (uint, error) { return ToUint(in) }
|
||||
|
||||
// SafeUint convert any to uint, will ignore error
|
||||
func SafeUint(in any) uint64 {
|
||||
func SafeUint(in any) uint {
|
||||
val, _ := ToUint(in)
|
||||
return val
|
||||
}
|
||||
|
||||
// QuietUint convert any to uint, will ignore error
|
||||
func QuietUint(in any) uint64 {
|
||||
return SafeUint(in)
|
||||
}
|
||||
func QuietUint(in any) uint { return SafeUint(in) }
|
||||
|
||||
// MustUint convert any to uint, will panic on error
|
||||
func MustUint(in any) uint64 {
|
||||
val, err := ToUintWithFunc(in, nil)
|
||||
func MustUint(in any) uint {
|
||||
val, err := ToUintWith(in)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
@@ -195,13 +363,11 @@ func MustUint(in any) uint64 {
|
||||
}
|
||||
|
||||
// UintOrDefault convert any to uint, return default val on failed
|
||||
func UintOrDefault(in any, defVal uint64) uint64 {
|
||||
return UintOr(in, defVal)
|
||||
}
|
||||
func UintOrDefault(in any, defVal uint) uint { return UintOr(in, defVal) }
|
||||
|
||||
// UintOr convert any to uint, return default val on failed
|
||||
func UintOr(in any, defVal uint64) uint64 {
|
||||
val, err := ToUintWithFunc(in, nil)
|
||||
func UintOr(in any, defVal uint) uint {
|
||||
val, err := ToUintWith(in)
|
||||
if err != nil {
|
||||
return defVal
|
||||
}
|
||||
@@ -209,17 +375,124 @@ func UintOr(in any, defVal uint64) uint64 {
|
||||
}
|
||||
|
||||
// UintOrErr convert value to uint, return error on failed
|
||||
func UintOrErr(in any) (uint64, error) {
|
||||
return ToUintWithFunc(in, nil)
|
||||
}
|
||||
func UintOrErr(in any) (uint, error) { return ToUintWith(in) }
|
||||
|
||||
// ToUint convert value to uint, return error on failed
|
||||
func ToUint(in any) (u64 uint64, err error) {
|
||||
return ToUintWithFunc(in, nil)
|
||||
func ToUint(in any) (u64 uint, err error) { return ToUintWith(in) }
|
||||
|
||||
// ToUintWith try to convert value to uint. can with some option func, more see ConvOption.
|
||||
func ToUintWith(in any, optFns ...ConvOptionFn[uint]) (uVal uint, err error) {
|
||||
opt := NewConvOption(optFns...)
|
||||
if !opt.NilAsFail && in == nil {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
switch tVal := in.(type) {
|
||||
case int:
|
||||
uVal = uint(tVal)
|
||||
case int8:
|
||||
uVal = uint(tVal)
|
||||
case int16:
|
||||
uVal = uint(tVal)
|
||||
case int32:
|
||||
uVal = uint(tVal)
|
||||
case int64:
|
||||
uVal = uint(tVal)
|
||||
case uint:
|
||||
uVal = tVal
|
||||
case *uint: // default support uint ptr type
|
||||
uVal = *tVal
|
||||
case uint8:
|
||||
uVal = uint(tVal)
|
||||
case uint16:
|
||||
uVal = uint(tVal)
|
||||
case uint32:
|
||||
uVal = uint(tVal)
|
||||
case uint64:
|
||||
uVal = uint(tVal)
|
||||
case float32:
|
||||
uVal = uint(tVal)
|
||||
case float64:
|
||||
uVal = uint(tVal)
|
||||
case time.Duration:
|
||||
uVal = uint(tVal)
|
||||
case comdef.Int64able: // eg: json.Number
|
||||
var i64 int64
|
||||
i64, err = tVal.Int64()
|
||||
uVal = uint(i64)
|
||||
case string:
|
||||
var u64 uint64
|
||||
u64, err = strconv.ParseUint(strings.TrimSpace(tVal), 10, 0)
|
||||
uVal = uint(u64)
|
||||
default:
|
||||
if opt.HandlePtr {
|
||||
if rv := reflect.ValueOf(in); rv.Kind() == reflect.Pointer {
|
||||
rv = rv.Elem()
|
||||
if checkfn.IsSimpleKind(rv.Kind()) {
|
||||
return ToUintWith(rv.Interface(), optFns...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if opt.UserConvFn != nil {
|
||||
uVal, err = opt.UserConvFn(in)
|
||||
} else {
|
||||
err = comdef.ErrConvType
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ToUintWithFunc convert value to uint, will call usrFn on value type not supported.
|
||||
func ToUintWithFunc(in any, usrFn ToUintFunc) (u64 uint64, err error) {
|
||||
/*************************************************************
|
||||
* convert value to uint64
|
||||
*************************************************************/
|
||||
|
||||
// Uint64 convert any to uint64, return error on failed
|
||||
func Uint64(in any) (uint64, error) { return ToUint64(in) }
|
||||
|
||||
// QuietUint64 convert any to uint64, will ignore error
|
||||
func QuietUint64(in any) uint64 { return SafeUint64(in) }
|
||||
|
||||
// SafeUint64 convert any to uint64, will ignore error
|
||||
func SafeUint64(in any) uint64 {
|
||||
val, _ := ToUint64(in)
|
||||
return val
|
||||
}
|
||||
|
||||
// MustUint64 convert any to uint64, will panic on error
|
||||
func MustUint64(in any) uint64 {
|
||||
val, err := ToUint64With(in)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return val
|
||||
}
|
||||
|
||||
// Uint64OrDefault convert any to uint64, return default val on failed
|
||||
func Uint64OrDefault(in any, defVal uint64) uint64 { return Uint64Or(in, defVal) }
|
||||
|
||||
// Uint64Or convert any to uint64, return default val on failed
|
||||
func Uint64Or(in any, defVal uint64) uint64 {
|
||||
val, err := ToUint64With(in)
|
||||
if err != nil {
|
||||
return defVal
|
||||
}
|
||||
return val
|
||||
}
|
||||
|
||||
// Uint64OrErr convert value to uint64, return error on failed
|
||||
func Uint64OrErr(in any) (uint64, error) { return ToUint64With(in) }
|
||||
|
||||
// ToUint64 convert value to uint64, return error on failed
|
||||
func ToUint64(in any) (uint64, error) { return ToUint64With(in) }
|
||||
|
||||
// ToUint64With try to convert value to uint64. can with some option func, more see ConvOption.
|
||||
func ToUint64With(in any, optFns ...ConvOptionFn[uint64]) (u64 uint64, err error) {
|
||||
opt := NewConvOption(optFns...)
|
||||
if !opt.NilAsFail && in == nil {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
switch tVal := in.(type) {
|
||||
case int:
|
||||
u64 = uint64(tVal)
|
||||
@@ -241,21 +514,32 @@ func ToUintWithFunc(in any, usrFn ToUintFunc) (u64 uint64, err error) {
|
||||
u64 = uint64(tVal)
|
||||
case uint64:
|
||||
u64 = tVal
|
||||
case *uint64: // default support uint64 ptr type
|
||||
u64 = *tVal
|
||||
case float32:
|
||||
u64 = uint64(tVal)
|
||||
case float64:
|
||||
u64 = uint64(tVal)
|
||||
case time.Duration:
|
||||
u64 = uint64(tVal)
|
||||
case interface{ Int64() (int64, error) }: // eg: json.Number
|
||||
case comdef.Int64able: // eg: json.Number
|
||||
var i64 int64
|
||||
i64, err = tVal.Int64()
|
||||
u64 = uint64(i64)
|
||||
case string:
|
||||
u64, err = strconv.ParseUint(strings.TrimSpace(tVal), 10, 0)
|
||||
default:
|
||||
if usrFn != nil {
|
||||
u64, err = usrFn(in)
|
||||
if opt.HandlePtr {
|
||||
if rv := reflect.ValueOf(in); rv.Kind() == reflect.Pointer {
|
||||
rv = rv.Elem()
|
||||
if checkfn.IsSimpleKind(rv.Kind()) {
|
||||
return ToUint64With(rv.Interface(), optFns...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if opt.UserConvFn != nil {
|
||||
u64, err = opt.UserConvFn(in)
|
||||
} else {
|
||||
err = comdef.ErrConvType
|
||||
}
|
||||
@@ -264,124 +548,24 @@ func ToUintWithFunc(in any, usrFn ToUintFunc) (u64 uint64, err error) {
|
||||
}
|
||||
|
||||
/*************************************************************
|
||||
* convert value to int64
|
||||
*************************************************************/
|
||||
|
||||
// Int64 convert value to int64, return error on failed
|
||||
func Int64(in any) (int64, error) {
|
||||
return ToInt64(in)
|
||||
}
|
||||
|
||||
// SafeInt64 convert value to int64, will ignore error
|
||||
func SafeInt64(in any) int64 {
|
||||
i64, _ := ToInt64WithFunc(in, nil)
|
||||
return i64
|
||||
}
|
||||
|
||||
// QuietInt64 convert value to int64, will ignore error
|
||||
func QuietInt64(in any) int64 {
|
||||
return SafeInt64(in)
|
||||
}
|
||||
|
||||
// MustInt64 convert value to int64, will panic on error
|
||||
func MustInt64(in any) int64 {
|
||||
i64, err := ToInt64WithFunc(in, nil)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return i64
|
||||
}
|
||||
|
||||
// Int64OrDefault convert value to int64, return default val on failed
|
||||
func Int64OrDefault(in any, defVal int64) int64 {
|
||||
return Int64Or(in, defVal)
|
||||
}
|
||||
|
||||
// Int64Or convert value to int64, return default val on failed
|
||||
func Int64Or(in any, defVal int64) int64 {
|
||||
i64, err := ToInt64WithFunc(in, nil)
|
||||
if err != nil {
|
||||
return defVal
|
||||
}
|
||||
return i64
|
||||
}
|
||||
|
||||
// Int64OrErr convert value to int64, return error on failed
|
||||
func Int64OrErr(in any) (int64, error) {
|
||||
return ToInt64(in)
|
||||
}
|
||||
|
||||
// ToInt64 convert value to int64, return error on failed
|
||||
func ToInt64(in any) (i64 int64, err error) {
|
||||
return ToInt64WithFunc(in, nil)
|
||||
}
|
||||
|
||||
// ToInt64WithFunc convert value to int64, will call usrFn on value type not supported.
|
||||
func ToInt64WithFunc(in any, usrFn ToInt64Func) (i64 int64, err error) {
|
||||
switch tVal := in.(type) {
|
||||
case string:
|
||||
i64, err = strconv.ParseInt(strings.TrimSpace(tVal), 10, 0)
|
||||
case int:
|
||||
i64 = int64(tVal)
|
||||
case int8:
|
||||
i64 = int64(tVal)
|
||||
case int16:
|
||||
i64 = int64(tVal)
|
||||
case int32:
|
||||
i64 = int64(tVal)
|
||||
case int64:
|
||||
i64 = tVal
|
||||
case uint:
|
||||
i64 = int64(tVal)
|
||||
case uint8:
|
||||
i64 = int64(tVal)
|
||||
case uint16:
|
||||
i64 = int64(tVal)
|
||||
case uint32:
|
||||
i64 = int64(tVal)
|
||||
case uint64:
|
||||
i64 = int64(tVal)
|
||||
case float32:
|
||||
i64 = int64(tVal)
|
||||
case float64:
|
||||
i64 = int64(tVal)
|
||||
case time.Duration:
|
||||
i64 = int64(tVal)
|
||||
case interface{ Int64() (int64, error) }: // eg: json.Number
|
||||
i64, err = tVal.Int64()
|
||||
default:
|
||||
if usrFn != nil {
|
||||
i64, err = usrFn(in)
|
||||
} else {
|
||||
err = comdef.ErrConvType
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
/*************************************************************
|
||||
* convert value to float
|
||||
* convert value to float64
|
||||
*************************************************************/
|
||||
|
||||
// QuietFloat convert value to float64, will ignore error. alias of SafeFloat
|
||||
func QuietFloat(in any) float64 {
|
||||
return SafeFloat(in)
|
||||
}
|
||||
func QuietFloat(in any) float64 { return SafeFloat(in) }
|
||||
|
||||
// SafeFloat convert value to float64, will ignore error
|
||||
func SafeFloat(in any) float64 {
|
||||
val, _ := ToFloatWithFunc(in, nil)
|
||||
val, _ := ToFloatWith(in)
|
||||
return val
|
||||
}
|
||||
|
||||
// FloatOrPanic convert value to float64, will panic on error
|
||||
func FloatOrPanic(in any) float64 {
|
||||
return MustFloat(in)
|
||||
}
|
||||
func FloatOrPanic(in any) float64 { return MustFloat(in) }
|
||||
|
||||
// MustFloat convert value to float64, will panic on error
|
||||
func MustFloat(in any) float64 {
|
||||
val, err := ToFloatWithFunc(in, nil)
|
||||
val, err := ToFloatWith(in)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
@@ -389,13 +573,11 @@ func MustFloat(in any) float64 {
|
||||
}
|
||||
|
||||
// FloatOrDefault convert value to float64, will return default value on error
|
||||
func FloatOrDefault(in any, defVal float64) float64 {
|
||||
return FloatOr(in, defVal)
|
||||
}
|
||||
func FloatOrDefault(in any, defVal float64) float64 { return FloatOr(in, defVal) }
|
||||
|
||||
// FloatOr convert value to float64, will return default value on error
|
||||
func FloatOr(in any, defVal float64) float64 {
|
||||
val, err := ToFloatWithFunc(in, nil)
|
||||
val, err := ToFloatWith(in)
|
||||
if err != nil {
|
||||
return defVal
|
||||
}
|
||||
@@ -403,22 +585,21 @@ func FloatOr(in any, defVal float64) float64 {
|
||||
}
|
||||
|
||||
// Float convert value to float64, return error on failed
|
||||
func Float(in any) (float64, error) {
|
||||
return ToFloatWithFunc(in, nil)
|
||||
}
|
||||
func Float(in any) (float64, error) { return ToFloatWith(in) }
|
||||
|
||||
// FloatOrErr convert value to float64, return error on failed
|
||||
func FloatOrErr(in any) (float64, error) {
|
||||
return ToFloatWithFunc(in, nil)
|
||||
}
|
||||
func FloatOrErr(in any) (float64, error) { return ToFloatWith(in) }
|
||||
|
||||
// ToFloat convert value to float64, return error on failed
|
||||
func ToFloat(in any) (f64 float64, err error) {
|
||||
return ToFloatWithFunc(in, nil)
|
||||
}
|
||||
func ToFloat(in any) (float64, error) { return ToFloatWith(in) }
|
||||
|
||||
// ToFloatWith try to convert value to float64. can with some option func, more see ConvOption.
|
||||
func ToFloatWith(in any, optFns ...ConvOptionFn[float64]) (f64 float64, err error) {
|
||||
opt := NewConvOption(optFns...)
|
||||
if !opt.NilAsFail && in == nil {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// ToFloatWithFunc convert value to float64, will call usrFn if value type not supported.
|
||||
func ToFloatWithFunc(in any, usrFn ToFloatFunc) (f64 float64, err error) {
|
||||
switch tVal := in.(type) {
|
||||
case string:
|
||||
f64, err = strconv.ParseFloat(strings.TrimSpace(tVal), 64)
|
||||
@@ -446,13 +627,24 @@ func ToFloatWithFunc(in any, usrFn ToFloatFunc) (f64 float64, err error) {
|
||||
f64 = float64(tVal)
|
||||
case float64:
|
||||
f64 = tVal
|
||||
case *float64: // default support float64 ptr type
|
||||
f64 = *tVal
|
||||
case time.Duration:
|
||||
f64 = float64(tVal)
|
||||
case interface{ Float64() (float64, error) }: // eg: json.Number
|
||||
case comdef.Float64able: // eg: json.Number
|
||||
f64, err = tVal.Float64()
|
||||
default:
|
||||
if usrFn != nil {
|
||||
f64, err = usrFn(in)
|
||||
if opt.HandlePtr {
|
||||
if rv := reflect.ValueOf(in); rv.Kind() == reflect.Pointer {
|
||||
rv = rv.Elem()
|
||||
if checkfn.IsSimpleKind(rv.Kind()) {
|
||||
return ToFloatWith(rv.Interface(), optFns...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if opt.UserConvFn != nil {
|
||||
f64, err = opt.UserConvFn(in)
|
||||
} else {
|
||||
err = comdef.ErrConvType
|
||||
}
|
||||
@@ -466,7 +658,7 @@ func ToFloatWithFunc(in any, usrFn ToFloatFunc) (f64 float64, err error) {
|
||||
|
||||
// MustString convert intX/floatX value to string, will panic on error
|
||||
func MustString(val any) string {
|
||||
str, err := ToStringWithFunc(val, nil)
|
||||
str, err := ToStringWith(val)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
@@ -477,13 +669,11 @@ func MustString(val any) string {
|
||||
func StringOrPanic(val any) string { return MustString(val) }
|
||||
|
||||
// StringOrDefault convert intX/floatX value to string, will return default value on error
|
||||
func StringOrDefault(val any, defVal string) string {
|
||||
return StringOr(val, defVal)
|
||||
}
|
||||
func StringOrDefault(val any, defVal string) string { return StringOr(val, defVal) }
|
||||
|
||||
// StringOr convert intX/floatX value to string, will return default value on error
|
||||
func StringOr(val any, defVal string) string {
|
||||
str, err := ToStringWithFunc(val, nil)
|
||||
str, err := ToStringWith(val)
|
||||
if err != nil {
|
||||
return defVal
|
||||
}
|
||||
@@ -491,19 +681,13 @@ func StringOr(val any, defVal string) string {
|
||||
}
|
||||
|
||||
// ToString convert intX/floatX value to string, return error on failed
|
||||
func ToString(val any) (string, error) {
|
||||
return ToStringWithFunc(val, nil)
|
||||
}
|
||||
func ToString(val any) (string, error) { return ToStringWith(val) }
|
||||
|
||||
// StringOrErr convert intX/floatX value to string, return error on failed
|
||||
func StringOrErr(val any) (string, error) {
|
||||
return ToStringWithFunc(val, nil)
|
||||
}
|
||||
func StringOrErr(val any) (string, error) { return ToStringWith(val) }
|
||||
|
||||
// QuietString convert intX/floatX value to string, other type convert by fmt.Sprint
|
||||
func QuietString(val any) string {
|
||||
return SafeString(val)
|
||||
}
|
||||
func QuietString(val any) string { return SafeString(val) }
|
||||
|
||||
// String convert intX/floatX value to string, other type convert by fmt.Sprint
|
||||
func String(val any) string {
|
||||
@@ -520,76 +704,15 @@ func SafeString(val any) string {
|
||||
// TryToString try convert intX/floatX value to string
|
||||
//
|
||||
// if defaultAsErr is False, will use fmt.Sprint convert other type
|
||||
func TryToString(val any, defaultAsErr bool) (str string, err error) {
|
||||
var usrFn comdef.ToStringFunc
|
||||
func TryToString(val any, defaultAsErr bool) (string, error) {
|
||||
var optFn comfunc.ConvOptionFn
|
||||
if !defaultAsErr {
|
||||
usrFn = func(v any) (string, error) {
|
||||
if val == nil {
|
||||
return "", nil
|
||||
}
|
||||
return fmt.Sprint(v), nil
|
||||
}
|
||||
optFn = comfunc.WithUserConvFn(comfunc.StrBySprintFn)
|
||||
}
|
||||
|
||||
return ToStringWithFunc(val, usrFn)
|
||||
return ToStringWith(val, optFn)
|
||||
}
|
||||
|
||||
// ToStringWithFunc try convert intX/floatX value to string, will call usrFn if value type not supported.
|
||||
//
|
||||
// if defaultAsErr is False, will use fmt.Sprint convert other type
|
||||
func ToStringWithFunc(val any, usrFn comdef.ToStringFunc) (str string, err error) {
|
||||
switch value := val.(type) {
|
||||
case int:
|
||||
str = strconv.Itoa(value)
|
||||
case int8:
|
||||
str = strconv.Itoa(int(value))
|
||||
case int16:
|
||||
str = strconv.Itoa(int(value))
|
||||
case int32: // same as `rune`
|
||||
str = strconv.Itoa(int(value))
|
||||
case int64:
|
||||
str = strconv.FormatInt(value, 10)
|
||||
case uint:
|
||||
str = strconv.FormatUint(uint64(value), 10)
|
||||
case uint8:
|
||||
str = strconv.FormatUint(uint64(value), 10)
|
||||
case uint16:
|
||||
str = strconv.FormatUint(uint64(value), 10)
|
||||
case uint32:
|
||||
str = strconv.FormatUint(uint64(value), 10)
|
||||
case uint64:
|
||||
str = strconv.FormatUint(value, 10)
|
||||
case float32:
|
||||
str = strconv.FormatFloat(float64(value), 'f', -1, 32)
|
||||
case float64:
|
||||
str = strconv.FormatFloat(value, 'f', -1, 64)
|
||||
case time.Duration:
|
||||
str = strconv.FormatInt(int64(value), 10)
|
||||
case string:
|
||||
str = value
|
||||
case fmt.Stringer:
|
||||
str = value.String()
|
||||
default:
|
||||
if usrFn != nil {
|
||||
str, err = usrFn(val)
|
||||
} else {
|
||||
err = comdef.ErrConvType
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Percent returns a values percent of the total
|
||||
func Percent(val, total int) float64 {
|
||||
if total == 0 {
|
||||
return float64(0)
|
||||
}
|
||||
return (float64(val) / float64(total)) * 100
|
||||
}
|
||||
|
||||
// ElapsedTime calc elapsed time 计算运行时间消耗 单位 ms(毫秒)
|
||||
//
|
||||
// Deprecated: use timex.ElapsedTime()
|
||||
func ElapsedTime(startTime time.Time) string {
|
||||
return fmt.Sprintf("%.3f", time.Since(startTime).Seconds()*1000)
|
||||
// ToStringWith try to convert value to string. can with some option func, more see comfunc.ConvOption.
|
||||
func ToStringWith(in any, optFns ...comfunc.ConvOptionFn) (string, error) {
|
||||
return comfunc.ToStringWith(in, optFns...)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user