init

intUtil/any.go

@@ -0,0 +1,138 @@
+package intUtil
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// AnyToInt converts any input value to int
+func AnyToInt(input interface{}) (int, error) {
+	switch input.(type) {
+	case int:
+		return input.(int), nil
+	case int8:
+		return int(input.(int8)), nil
+	case int16:
+		return int(input.(int16)), nil
+	case int32:
+		return int(input.(int32)), nil
+	case int64:
+		return int(input.(int64)), nil
+	case uint:
+		return int(input.(uint)), nil
+	case uint8:
+		return int(input.(uint8)), nil
+	case uint16:
+		return int(input.(uint16)), nil
+	case uint32:
+		return int(input.(uint32)), nil
+	case uint64:
+		return int(input.(uint64)), nil
+	case string:
+		return strconv.Atoi(input.(string))
+	default:
+		return 0, fmt.Errorf("unsupported type %T", input)
+	}
+}
+
+// AnyToInt8 converts any input value to int8
+func AnyToInt8(input interface{}) (int8, error) {
+	value, err := AnyToInt(input)
+	if err != nil {
+		return 0, err
+	}
+	if value < -128 || value > 127 {
+		return 0, fmt.Errorf("%d out of int8 range", value)
+	}
+	return int8(value), nil
+}
+
+// AnyToInt16 converts any input value to int16
+func AnyToInt16(input interface{}) (int16, error) {
+	value, err := AnyToInt(input)
+	if err != nil {
+		return 0, err
+	}
+	if value < -32768 || value > 32767 {
+		return 0, fmt.Errorf("%d out of int16 range", value)
+	}
+	return int16(value), nil
+}
+
+// AnyToInt32 converts any input value to int32
+func AnyToInt32(input interface{}) (int32, error) {
+	value, err := AnyToInt(input)
+	if err != nil {
+		return 0, err
+	}
+	if value < -2147483648 || value > 2147483647 {
+		return 0, fmt.Errorf("%d out of int32 range", value)
+	}
+	return int32(value), nil
+}
+
+// AnyToInt64 converts any input value to int64
+func AnyToInt64(input interface{}) (int64, error) {
+	value, err := AnyToInt(input)
+	if err != nil {
+		return 0, err
+	}
+	return int64(value), nil
+}
+
+// AnyToUint converts any input value to uint
+func AnyToUint(input interface{}) (uint, error) {
+	value, err := AnyToInt(input)
+	if err != nil {
+		return 0, err
+	}
+	if value < 0 {
+		return 0, fmt.Errorf("%d is negative", value)
+	}
+	return uint(value), nil
+}
+
+// AnyToUint8 converts any input value to uint8
+func AnyToUint8(input interface{}) (uint8, error) {
+	value, err := AnyToUint(input)
+	if err != nil {
+		return 0, err
+	}
+	if value > 255 {
+		return 0, fmt.Errorf("%d out of uint8 range", value)
+	}
+	return uint8(value), nil
+}
+
+// AnyToUint16 converts any input value to uint16
+func AnyToUint16(input interface{}) (uint16, error) {
+	value, err := AnyToUint(input)
+	if err != nil {
+		return 0, err
+	}
+	if value > 65535 {
+		return 0, fmt.Errorf("%d out of uint16 range", value)
+	}
+	return uint16(value), nil
+}
+
+// AnyToUint32 converts any input value to uint32
+func AnyToUint32(input interface{}) (uint32, error) {
+	value, err := AnyToUint(input)
+	if err != nil {
+		return 0, err
+	}
+	if value > 4294967295 {
+		return 0, fmt.Errorf("%d out of uint32 range", value)
+	}
+	return uint32(value), nil
+}
+
+// AnyToUint64 converts any input value to uint64
+func AnyToUint64(input interface{}) (uint64, error) {
+	value, err := AnyToUint(input)
+	if err != nil {
+		return 0, err
+	}
+	return uint64(value), nil
+}

sliceUtil/sum.go

@@ -7,3 +7,35 @@ func SumInt(slice []int) int {
 	}
 	return sum
 }
+
+func SumInt8(slice []int8) int8 {
+	var sum int8
+	for _, v := range slice {
+		sum += v
+	}
+	return sum
+}
+
+func SumInt16(slice []int16) int16 {
+	var sum int16
+	for _, v := range slice {
+		sum += v
+	}
+	return sum
+}
+
+func SumInt32(slice []int32) int32 {
+	var sum int32
+	for _, v := range slice {
+		sum += v
+	}
+	return sum
+}
+
+func SumInt64(slice []int64) int64 {
+	var sum int64
+	for _, v := range slice {
+		sum += v
+	}
+	return sum
+}

strUtil/str_util.go

@@ -1 +0,0 @@
-package strUtil

strUtil/to.go

@@ -0,0 +1,51 @@
+package strUtil
+
+import (
+	"log"
+	"strconv"
+)
+
+func StrToInt(str string) int {
+	i, err := strconv.Atoi(str)
+	if err != nil {
+		log.Printf("StrToInt(%s) err:%s \n", str, err.Error())
+		return 0
+	}
+	return i
+}
+
+func StrToInt8(str string) int8 {
+	i, err := strconv.ParseInt(str, 10, 8)
+	if err != nil {
+		log.Printf("StrToInt8(%s) err:%s \n", str, err.Error())
+		return 0
+	}
+	return int8(i)
+}
+
+func StrToInt16(str string) int16 {
+	i, err := strconv.ParseInt(str, 10, 16)
+	if err != nil {
+		log.Printf("StrToInt16(%s) err:%s \n", str, err.Error())
+		return 0
+	}
+	return int16(i)
+}
+
+func StrToInt32(str string) int32 {
+	i, err := strconv.ParseInt(str, 10, 32)
+	if err != nil {
+		log.Printf("StrToInt32(%s) err:%s \n", str, err.Error())
+		return 0
+	}
+	return int32(i)
+}
+
+func StrToInt64(str string) int64 {
+	i, err := strconv.ParseInt(str, 10, 64)
+	if err != nil {
+		log.Printf("StrToInt64(%s) err:%s \n", str, err.Error())
+		return 0
+	}
+	return i
+}

uintUtil/uint_util.go

@@ -1 +0,0 @@
-package uintUtil