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 f64, err := strconv.ParseFloat(val, 32); err == nil { return float32(f64) } 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 f64, err := strconv.ParseFloat(val, 32); err == nil { return f64 } 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: if strings.ToLower(val) == "true" { return true } else if strings.ToLower(val) == "false" { return false } else if i, err := strconv.Atoi(val); err == nil { return i > 0 } return false default: return false } }