move any helper methods to common and reuse for params getter

internal/common/common.go

@@ -0,0 +1,179 @@
+package common
+
+import (
+	"math"
+	"reflect"
+)
+
+func GetAnyAs[T any](value any) (T, bool) {
+	typed, ok := value.(T)
+	return typed, ok
+}
+
+func GetAnyAsInt(value any) (int, bool) {
+
+	intValue, ok := value.(int)
+	if ok {
+		return intValue, true
+	}
+
+	uintValue, ok := value.(uint)
+	if ok {
+		return int(uintValue), true
+	}
+
+	byteValue, ok := value.(byte)
+	if ok {
+		return int(byteValue), true
+	}
+
+	floatValue, ok := value.(float64)
+	if ok {
+		if floatValue != math.Floor(floatValue) {
+			return 0, false
+		}
+		return int(floatValue), true
+	}
+	return 0, false
+}
+
+func GetAnyAsByteSlice(value any) ([]byte, bool) {
+	v := reflect.ValueOf(value)
+	if v.Kind() != reflect.Slice {
+		return nil, false
+	}
+
+	result := make([]byte, v.Len())
+	for i := 0; i < v.Len(); i++ {
+		elem := v.Index(i).Interface()
+		byteValue, ok := elem.(byte)
+		if ok {
+			result[i] = byteValue
+			continue
+		}
+		uintValue, ok := elem.(uint)
+		if ok {
+			if uintValue > 255 {
+				return nil, false
+			}
+			result[i] = byte(uintValue)
+			continue
+		}
+		intValue, ok := elem.(int)
+		if ok {
+			if intValue < 0 || intValue > 255 {
+				return nil, false
+			}
+			result[i] = byte(intValue)
+			continue
+		}
+		floatValue, ok := elem.(float64)
+		if ok {
+			if floatValue != math.Floor(floatValue) {
+				return nil, false
+			}
+			if floatValue < 0 || floatValue > 255 {
+				return nil, false
+			}
+			result[i] = byte(floatValue)
+			continue
+		}
+		return nil, false
+	}
+	return result, true
+}
+
+func GetAnyAsIntSlice(value any) ([]int, bool) {
+	v := reflect.ValueOf(value)
+	if v.Kind() != reflect.Slice {
+		return nil, false
+	}
+
+	result := make([]int, v.Len())
+	for i := 0; i < v.Len(); i++ {
+		elem := v.Index(i).Interface()
+		byteValue, ok := elem.(byte)
+		if ok {
+			result[i] = int(byteValue)
+			continue
+		}
+		uintValue, ok := elem.(uint)
+		if ok {
+			result[i] = int(uintValue)
+			continue
+		}
+		intValue, ok := elem.(int)
+		if ok {
+			result[i] = int(intValue)
+			continue
+		}
+		floatValue, ok := elem.(float64)
+		if ok {
+			if floatValue != math.Floor(floatValue) {
+				return nil, false
+			}
+			result[i] = int(floatValue)
+			continue
+		}
+		return nil, false
+	}
+	return result, true
+}
+
+func GetAnyAsFloat32(value any) (float32, bool) {
+	float32Value, ok := value.(float32)
+	if ok {
+		return float32Value, true
+	}
+
+	float64Value, ok := value.(float64)
+	if ok {
+		return float32(float64Value), true
+	}
+
+	intValue, ok := value.(int)
+	if ok {
+		return float32(intValue), true
+	}
+
+	uintValue, ok := value.(uint)
+	if ok {
+		return float32(uintValue), true
+	}
+
+	byteValue, ok := value.(byte)
+	if ok {
+		return float32(byteValue), true
+	}
+
+	return 0, false
+}
+
+func GetAnyAsFloat64(value any) (float64, bool) {
+	float64Value, ok := value.(float64)
+	if ok {
+		return float64Value, true
+	}
+
+	float32Value, ok := value.(float32)
+	if ok {
+		return float64(float32Value), true
+	}
+
+	intValue, ok := value.(int)
+	if ok {
+		return float64(intValue), true
+	}
+
+	uintValue, ok := value.(uint)
+	if ok {
+		return float64(uintValue), true
+	}
+
+	byteValue, ok := value.(byte)
+	if ok {
+		return float64(byteValue), true
+	}
+
+	return 0, false
+}