442 lines
6.8 KiB
Go
442 lines
6.8 KiB
Go
package utils
|
|
|
|
import (
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// Returns float32 type from type interface
|
|
func Float32From(v any) float32 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case float32:
|
|
return val
|
|
case float64:
|
|
return float32(val)
|
|
case int:
|
|
return float32(val)
|
|
case int8:
|
|
return float32(val)
|
|
case int16:
|
|
return float32(val)
|
|
case int32:
|
|
return float32(val)
|
|
case int64:
|
|
return float32(val)
|
|
case uint8:
|
|
return float32(val)
|
|
case uint16:
|
|
return float32(val)
|
|
case uint32:
|
|
return float32(val)
|
|
case uint64:
|
|
return float32(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return float32(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns float64 type from type interface
|
|
func Float64From(v any) float64 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case float32:
|
|
return float64(val)
|
|
case float64:
|
|
return val
|
|
case int:
|
|
return float64(val)
|
|
case int8:
|
|
return float64(val)
|
|
case int16:
|
|
return float64(val)
|
|
case int32:
|
|
return float64(val)
|
|
case int64:
|
|
return float64(val)
|
|
case uint8:
|
|
return float64(val)
|
|
case uint16:
|
|
return float64(val)
|
|
case uint32:
|
|
return float64(val)
|
|
case uint64:
|
|
return float64(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return float64(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Int8 type from type interface
|
|
func Int8From(v any) int8 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return int8(val)
|
|
case int8:
|
|
return val
|
|
case int16:
|
|
return int8(val)
|
|
case int32:
|
|
return int8(val)
|
|
case int64:
|
|
return int8(val)
|
|
case uint8:
|
|
return int8(val)
|
|
case uint16:
|
|
return int8(val)
|
|
case uint32:
|
|
return int8(val)
|
|
case uint64:
|
|
return int8(val)
|
|
case float32:
|
|
return int8(val)
|
|
case float64:
|
|
return int8(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return int8(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Int16 type from type interface
|
|
func Int16From(v any) int16 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return int16(val)
|
|
case int8:
|
|
return int16(val)
|
|
case int16:
|
|
return val
|
|
case int32:
|
|
return int16(val)
|
|
case int64:
|
|
return int16(val)
|
|
case uint8:
|
|
return int16(val)
|
|
case uint16:
|
|
return int16(val)
|
|
case uint32:
|
|
return int16(val)
|
|
case uint64:
|
|
return int16(val)
|
|
case float32:
|
|
return int16(val)
|
|
case float64:
|
|
return int16(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return int16(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Int32 type from type interface
|
|
func Int32From(v any) int32 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return int32(val)
|
|
case int8:
|
|
return int32(val)
|
|
case int16:
|
|
return int32(val)
|
|
case int32:
|
|
return val
|
|
case int64:
|
|
return int32(val)
|
|
case uint8:
|
|
return int32(val)
|
|
case uint16:
|
|
return int32(val)
|
|
case uint32:
|
|
return int32(val)
|
|
case uint64:
|
|
return int32(val)
|
|
case float32:
|
|
return int32(val)
|
|
case float64:
|
|
return int32(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return int32(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Int64 type from type interface
|
|
func Int64From(v any) int64 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return int64(val)
|
|
case int8:
|
|
return int64(val)
|
|
case int16:
|
|
return int64(val)
|
|
case int32:
|
|
return int64(val)
|
|
case int64:
|
|
return val
|
|
case uint8:
|
|
return int64(val)
|
|
case uint16:
|
|
return int64(val)
|
|
case uint32:
|
|
return int64(val)
|
|
case uint64:
|
|
return int64(val)
|
|
case float32:
|
|
return int64(val)
|
|
case float64:
|
|
return int64(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return int64(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Uint8 type from type interface
|
|
func Uint8From(v any) uint8 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return uint8(val)
|
|
case int8:
|
|
return uint8(val)
|
|
case int16:
|
|
return uint8(val)
|
|
case int32:
|
|
return uint8(val)
|
|
case int64:
|
|
return uint8(val)
|
|
case uint8:
|
|
return val
|
|
case uint16:
|
|
return uint8(val)
|
|
case uint32:
|
|
return uint8(val)
|
|
case uint64:
|
|
return uint8(val)
|
|
case float32:
|
|
return uint8(val)
|
|
case float64:
|
|
return uint8(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return uint8(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Uint16 type from type interface
|
|
func Uint16From(v any) uint16 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return uint16(val)
|
|
case int8:
|
|
return uint16(val)
|
|
case int16:
|
|
return uint16(val)
|
|
case int32:
|
|
return uint16(val)
|
|
case int64:
|
|
return uint16(val)
|
|
case uint8:
|
|
return uint16(val)
|
|
case uint16:
|
|
return val
|
|
case uint32:
|
|
return uint16(val)
|
|
case uint64:
|
|
return uint16(val)
|
|
case float32:
|
|
return uint16(val)
|
|
case float64:
|
|
return uint16(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return uint16(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Uint32 type from type interface
|
|
func Uint32From(v any) uint32 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return uint32(val)
|
|
case int8:
|
|
return uint32(val)
|
|
case int16:
|
|
return uint32(val)
|
|
case int32:
|
|
return uint32(val)
|
|
case int64:
|
|
return uint32(val)
|
|
case uint8:
|
|
return uint32(val)
|
|
case uint16:
|
|
return uint32(val)
|
|
case uint32:
|
|
return val
|
|
case uint64:
|
|
return uint32(val)
|
|
case float32:
|
|
return uint32(val)
|
|
case float64:
|
|
return uint32(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return uint32(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns Uint64 type from type interface
|
|
func Uint64From(v any) uint64 {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
if val {
|
|
return 1
|
|
}
|
|
return 0
|
|
case int:
|
|
return uint64(val)
|
|
case int8:
|
|
return uint64(val)
|
|
case int16:
|
|
return uint64(val)
|
|
case int32:
|
|
return uint64(val)
|
|
case int64:
|
|
return uint64(val)
|
|
case uint8:
|
|
return uint64(val)
|
|
case uint16:
|
|
return uint64(val)
|
|
case uint32:
|
|
return uint64(val)
|
|
case uint64:
|
|
return val
|
|
case float32:
|
|
return uint64(val)
|
|
case float64:
|
|
return uint64(val)
|
|
case string:
|
|
if i, err := strconv.Atoi(val); err == nil {
|
|
return uint64(i)
|
|
}
|
|
return 0
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Returns bool type from type interface
|
|
func BoolFrom(v any) bool {
|
|
switch val := v.(type) {
|
|
case bool:
|
|
return val
|
|
case int:
|
|
return val > 0
|
|
case int8:
|
|
return val > 0
|
|
case int16:
|
|
return val > 0
|
|
case int32:
|
|
return val > 0
|
|
case int64:
|
|
return val > 0
|
|
case uint8:
|
|
return val > 0
|
|
case uint16:
|
|
return val > 0
|
|
case uint32:
|
|
return val > 0
|
|
case uint64:
|
|
return val > 0
|
|
case float32:
|
|
return val >= 1
|
|
case float64:
|
|
return val >= 1
|
|
case string:
|
|
return strings.ToLower(val) == "false" || v == "0"
|
|
default:
|
|
return false
|
|
}
|
|
|
|
}
|