You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
6.8 KiB
355 lines
6.8 KiB
package utils
|
|
|
|
import (
|
|
"reflect"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
func ValueType(in interface{}) string {
|
|
if in == nil {
|
|
return "<nil>"
|
|
}
|
|
switch in.(type) {
|
|
case int:
|
|
return "int"
|
|
case int8:
|
|
return "int8"
|
|
case int16:
|
|
return "int16"
|
|
case int32:
|
|
return "int32"
|
|
case int64:
|
|
return "int64"
|
|
case uint:
|
|
return "uint"
|
|
case uint8:
|
|
return "uint8"
|
|
case uint16:
|
|
return "uint16"
|
|
case uint32:
|
|
return "uint32"
|
|
case uint64:
|
|
return "uint64"
|
|
case float32:
|
|
return "float32"
|
|
case float64:
|
|
return "float64"
|
|
case []byte:
|
|
return "[]byte"
|
|
case string:
|
|
return "string"
|
|
case []string:
|
|
return "[]string"
|
|
case *[]byte:
|
|
return "*[]byte"
|
|
case *string:
|
|
return "*string"
|
|
case []*string:
|
|
return "[]*string"
|
|
default:
|
|
}
|
|
rv := reflect.ValueOf(in)
|
|
switch rv.Kind() {
|
|
case reflect.Map:
|
|
return "reflect.Map"
|
|
case reflect.Array:
|
|
return "reflect.Array"
|
|
case reflect.Slice:
|
|
return "reflect.Slice"
|
|
}
|
|
|
|
return "[" + rv.Kind().String() + "]" + reflect.TypeOf(in).Name()
|
|
}
|
|
|
|
func ValueToInt(in interface{}, def int) int {
|
|
if in == nil {
|
|
return def
|
|
}
|
|
switch in.(type) {
|
|
case int:
|
|
return in.(int)
|
|
case int8:
|
|
return int(in.(int8))
|
|
case int16:
|
|
return int(in.(int16))
|
|
case int32:
|
|
return int(in.(int32))
|
|
case int64:
|
|
return int(in.(int64))
|
|
case uint:
|
|
return int(in.(uint))
|
|
case uint8:
|
|
return int(in.(uint8))
|
|
case uint16:
|
|
return int(in.(uint16))
|
|
case uint32:
|
|
return int(in.(uint32))
|
|
case uint64:
|
|
return int(in.(uint64))
|
|
case float32:
|
|
return int(in.(float32))
|
|
case float64:
|
|
return int(in.(float64))
|
|
case []byte:
|
|
ii, _ := strconv.ParseFloat(string(in.([]byte)), 64)
|
|
return int(ii)
|
|
case string:
|
|
ii, _ := strconv.ParseFloat(in.(string), 64)
|
|
return int(ii)
|
|
case *[]byte:
|
|
ii, _ := strconv.ParseFloat(string(*(in.(*[]byte))), 64)
|
|
return int(ii)
|
|
case *string:
|
|
ii, _ := strconv.ParseFloat(*(in.(*string)), 64)
|
|
return int(ii)
|
|
default:
|
|
}
|
|
return def
|
|
}
|
|
func ValueToFloat(in interface{}, def float64) float64 {
|
|
if in == nil {
|
|
return def
|
|
}
|
|
switch in.(type) {
|
|
case int:
|
|
return float64(in.(int))
|
|
case int8:
|
|
return float64(in.(int8))
|
|
case int16:
|
|
return float64(in.(int16))
|
|
case int32:
|
|
return float64(in.(int32))
|
|
case int64:
|
|
return float64(in.(int64))
|
|
case uint:
|
|
return float64(in.(uint))
|
|
case uint8:
|
|
return float64(in.(uint8))
|
|
case uint16:
|
|
return float64(in.(uint16))
|
|
case uint32:
|
|
return float64(in.(uint32))
|
|
case uint64:
|
|
return float64(in.(uint64))
|
|
case float32:
|
|
return float64(in.(float32))
|
|
case float64:
|
|
return in.(float64)
|
|
case []byte:
|
|
ii, _ := strconv.ParseFloat(string(in.([]byte)), 64)
|
|
return ii
|
|
case string:
|
|
ii, _ := strconv.ParseFloat(in.(string), 64)
|
|
return ii
|
|
case *[]byte:
|
|
ii, _ := strconv.ParseFloat(string(*(in.(*[]byte))), 64)
|
|
return ii
|
|
case *string:
|
|
ii, _ := strconv.ParseFloat(*(in.(*string)), 64)
|
|
return ii
|
|
default:
|
|
}
|
|
return def
|
|
}
|
|
|
|
func ValueToString(in interface{}, def string) string {
|
|
return ValueToStringIn(in, def, 0)
|
|
}
|
|
|
|
func ValueToStringIn(in interface{}, def string, fixed int) string {
|
|
if in == nil {
|
|
return def
|
|
}
|
|
switch in.(type) {
|
|
case int:
|
|
return strconv.FormatInt(int64(in.(int)), 10)
|
|
case int8:
|
|
return strconv.FormatInt(int64(in.(int8)), 10)
|
|
case int16:
|
|
return strconv.FormatInt(int64(in.(int16)), 10)
|
|
case int32:
|
|
return strconv.FormatInt(int64(in.(int32)), 10)
|
|
case int64:
|
|
return strconv.FormatInt(in.(int64), 10)
|
|
case uint:
|
|
return strconv.FormatUint(uint64(in.(uint)), 10)
|
|
case uint8:
|
|
return strconv.FormatUint(uint64(in.(uint8)), 10)
|
|
case uint16:
|
|
return strconv.FormatUint(uint64(in.(uint16)), 10)
|
|
case uint32:
|
|
return strconv.FormatUint(uint64(in.(uint32)), 10)
|
|
case uint64:
|
|
return strconv.FormatUint(in.(uint64), 10)
|
|
case float32:
|
|
if fixed > 0 {
|
|
return strconv.FormatFloat(float64(in.(float32)), 'f', fixed, 32)
|
|
}
|
|
return strconv.FormatFloat(float64(in.(float32)), 'f', 10, 32)
|
|
case float64:
|
|
if fixed > 0 {
|
|
return strconv.FormatFloat(in.(float64), 'f', fixed, 64)
|
|
}
|
|
return strconv.FormatFloat(in.(float64), 'f', 10, 64)
|
|
case []byte:
|
|
return string(in.([]byte))
|
|
case string:
|
|
return in.(string)
|
|
case *[]byte:
|
|
return string(*(in.(*[]byte)))
|
|
case *string:
|
|
return *(in.(*string))
|
|
default:
|
|
}
|
|
return def
|
|
}
|
|
|
|
func ValueToTime(in interface{}, timeFormat string, def string) string {
|
|
if in == nil {
|
|
return def
|
|
}
|
|
switch in.(type) {
|
|
case time.Time:
|
|
return TimeFormat(in.(time.Time), timeFormat)
|
|
case *time.Time:
|
|
return TimeFormat(*(in.(*time.Time)), timeFormat)
|
|
case []byte:
|
|
return string(in.([]byte))
|
|
case string:
|
|
return in.(string)
|
|
case *[]byte:
|
|
return string(*(in.(*[]byte)))
|
|
case *string:
|
|
return *(in.(*string))
|
|
default:
|
|
res := ValueToInt(in, 0)
|
|
return TimeFormat(time.Unix(int64(res), 0), timeFormat)
|
|
}
|
|
return def
|
|
}
|
|
|
|
func ValueIsEmpty(in interface{}) bool {
|
|
if in == nil {
|
|
return true
|
|
}
|
|
|
|
rv := reflect.ValueOf(in)
|
|
switch rv.Kind() {
|
|
case reflect.Map, reflect.Array, reflect.Slice:
|
|
return rv.Len() == 0
|
|
}
|
|
|
|
switch in.(type) {
|
|
case bool:
|
|
return !in.(bool)
|
|
case *bool:
|
|
return !(*(in.(*bool)))
|
|
case int:
|
|
return in.(int) == 0
|
|
case int8:
|
|
return in.(int8) == 0
|
|
case int16:
|
|
return in.(int16) == 0
|
|
case int32:
|
|
return in.(int32) == 0
|
|
case int64:
|
|
return in.(int64) == 0
|
|
case uint:
|
|
return in.(uint) == 0
|
|
case uint8:
|
|
return in.(uint8) == 0
|
|
case uint16:
|
|
return in.(uint16) == 0
|
|
case uint32:
|
|
return in.(uint32) == 0
|
|
case uint64:
|
|
return in.(uint64) == 0
|
|
case float32:
|
|
return in.(float32) == 0.0
|
|
case float64:
|
|
return in.(float64) == 0.0
|
|
case string:
|
|
return len(in.(string)) == 0
|
|
case *string:
|
|
return len(*(in.(*string))) == 0
|
|
default:
|
|
}
|
|
return rv.IsNil()
|
|
}
|
|
|
|
func ValueToStringArray(in interface{}) []string {
|
|
arr, ok := in.([]interface{})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
res := make([]string, 0)
|
|
for _, v := range arr {
|
|
res = append(res, ValueToString(v, ""))
|
|
}
|
|
return res
|
|
}
|
|
|
|
func ValueToIntArray(in interface{}) []int {
|
|
arr, ok := in.([]interface{})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
res := make([]int, 0)
|
|
for _, v := range arr {
|
|
res = append(res, ValueToInt(v, 0))
|
|
}
|
|
return res
|
|
}
|
|
|
|
func ValueToFloatArray(in interface{}) []float64 {
|
|
arr, ok := in.([]interface{})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
res := make([]float64, 0)
|
|
for _, v := range arr {
|
|
res = append(res, ValueToFloat(v, 0.0))
|
|
}
|
|
return res
|
|
}
|
|
|
|
func ValueFromStringArray(in []string) []interface{} {
|
|
out := make([]interface{}, len(in))
|
|
for k, v := range in {
|
|
out[k] = v
|
|
}
|
|
return out
|
|
}
|
|
|
|
func ValueFromIntArray(in []int) []interface{} {
|
|
out := make([]interface{}, len(in))
|
|
for k, v := range in {
|
|
out[k] = v
|
|
}
|
|
return out
|
|
}
|
|
|
|
func ValueFromFloatArray(in []float64) []interface{} {
|
|
out := make([]interface{}, len(in))
|
|
for k, v := range in {
|
|
out[k] = v
|
|
}
|
|
return out
|
|
}
|
|
|
|
func IDsToString(ids []int) string {
|
|
ll := len(ids)
|
|
str := ""
|
|
for i := 0; i < ll; i++ {
|
|
if i > 0 {
|
|
str = str + "','" + ValueToString(ids[i], "")
|
|
} else {
|
|
str = "('" + ValueToString(ids[i], "")
|
|
}
|
|
}
|
|
if len(str) > 0 {
|
|
str = str + "')"
|
|
}
|
|
return str
|
|
}
|