mirror of
https://github.com/pyihe/go-pkg.git
synced 2025-10-07 00:43:21 +08:00
style(go-pkg): rename pkg
This commit is contained in:
pyihe
670
slicepkg/sli.go
Normal file
670
slicepkg/sli.go
Normal file
@@ -0,0 +1,670 @@
|
||||
package slicepkg
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"reflect"
|
||||
)
|
||||
|
||||
type Slice interface {
|
||||
Len() int
|
||||
Cap() int
|
||||
Sort()
|
||||
PushBack(x interface{}) (bool, int)
|
||||
PushFront(x interface{}) (bool, int)
|
||||
PopBack() (bool, interface{})
|
||||
PopFront() (bool, interface{})
|
||||
Index(x interface{}) int
|
||||
IndexValue(i int) interface{}
|
||||
Range(fn func(index int, ele interface{}) bool)
|
||||
Delete(x interface{}) (ok bool)
|
||||
}
|
||||
|
||||
func NewSlice(st reflect.Kind, capacity int) Slice {
|
||||
switch st {
|
||||
case reflect.Int8:
|
||||
return newInt8Slice(capacity)
|
||||
case reflect.Uint8:
|
||||
return newUint8Slice(capacity)
|
||||
case reflect.Int16:
|
||||
return newInt16Slice(capacity)
|
||||
case reflect.Uint16:
|
||||
return newUint16Slice(capacity)
|
||||
case reflect.Int:
|
||||
return newIntSlice(capacity)
|
||||
case reflect.Uint:
|
||||
return newUintSlice(capacity)
|
||||
case reflect.Int32:
|
||||
return newInt32Slice(capacity)
|
||||
case reflect.Uint32:
|
||||
return newUint32Slice(capacity)
|
||||
case reflect.Int64:
|
||||
return newInt64Slice(capacity)
|
||||
case reflect.Uint64:
|
||||
return newUint64Slice(capacity)
|
||||
case reflect.Float32:
|
||||
return newFloat32Slice(capacity)
|
||||
case reflect.Float64:
|
||||
return newFloat64Slice(capacity)
|
||||
case reflect.String:
|
||||
return newStringSlice(capacity)
|
||||
default:
|
||||
panic("not supported type")
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************分界线**************************************************************/
|
||||
func convertToFloat32(x interface{}) (ok bool, v float32) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
v = float32(d)
|
||||
case uint8:
|
||||
v = float32(d)
|
||||
case int16:
|
||||
v = float32(d)
|
||||
case uint16:
|
||||
v = float32(d)
|
||||
case int:
|
||||
v = float32(d)
|
||||
case uint:
|
||||
v = float32(d)
|
||||
case int32:
|
||||
v = float32(d)
|
||||
case uint32:
|
||||
v = float32(d)
|
||||
case int64:
|
||||
v = float32(d)
|
||||
case uint64:
|
||||
v = float32(d)
|
||||
case float32:
|
||||
v = d
|
||||
case float64:
|
||||
v = float32(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToFloat64(x interface{}) (bool, float64) {
|
||||
var v float64
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
v = float64(d)
|
||||
case uint8:
|
||||
v = float64(d)
|
||||
case int16:
|
||||
v = float64(d)
|
||||
case uint16:
|
||||
v = float64(d)
|
||||
case int:
|
||||
v = float64(d)
|
||||
case uint:
|
||||
v = float64(d)
|
||||
case int32:
|
||||
v = float64(d)
|
||||
case uint32:
|
||||
v = float64(d)
|
||||
case int64:
|
||||
v = float64(d)
|
||||
case uint64:
|
||||
v = float64(d)
|
||||
case float32:
|
||||
v = float64(d)
|
||||
case float64:
|
||||
v = d
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToInt(x interface{}) (bool, int) {
|
||||
var v int
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
v = int(d)
|
||||
case uint8:
|
||||
v = int(d)
|
||||
case int16:
|
||||
v = int(d)
|
||||
case uint16:
|
||||
v = int(d)
|
||||
case int:
|
||||
v = d
|
||||
case uint:
|
||||
v = int(d)
|
||||
case int32:
|
||||
v = int(d)
|
||||
case uint32:
|
||||
v = int(d)
|
||||
case int64:
|
||||
v = int(d)
|
||||
case uint64:
|
||||
v = int(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToUint(x interface{}) (ok bool, v uint) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint(d)
|
||||
case uint8:
|
||||
v = uint(d)
|
||||
case int16:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint(d)
|
||||
case uint16:
|
||||
v = uint(d)
|
||||
case int:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint(d)
|
||||
case uint:
|
||||
v = d
|
||||
case int32:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint(d)
|
||||
case uint32:
|
||||
v = uint(d)
|
||||
case int64:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint(d)
|
||||
case uint64:
|
||||
v = uint(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToInt8(x interface{}) (ok bool, v int8) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
v = d
|
||||
case uint8:
|
||||
if d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case int16:
|
||||
if d < math.MinInt8 || d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case uint16:
|
||||
if d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case int:
|
||||
if d < math.MinInt8 || d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case uint:
|
||||
if d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case int32:
|
||||
if d < math.MinInt8 || d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case uint32:
|
||||
if d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case int64:
|
||||
if d < math.MinInt8 || d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
case uint64:
|
||||
if d > math.MaxInt8 {
|
||||
return
|
||||
}
|
||||
v = int8(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToUint8(x interface{}) (ok bool, v uint8) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case uint8:
|
||||
v = d
|
||||
case int16:
|
||||
if d < 0 || d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case uint16:
|
||||
if d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case int:
|
||||
if d < 0 || d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case uint:
|
||||
if d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case int32:
|
||||
if d < 0 || d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case uint32:
|
||||
if d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case int64:
|
||||
if d < 0 || d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
case uint64:
|
||||
if d > math.MaxUint8 {
|
||||
return
|
||||
}
|
||||
v = uint8(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToInt16(x interface{}) (ok bool, v int16) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
v = int16(d)
|
||||
case uint8:
|
||||
v = int16(d)
|
||||
case int16:
|
||||
v = d
|
||||
case uint16:
|
||||
if v > math.MaxInt16 {
|
||||
return
|
||||
}
|
||||
v = int16(d)
|
||||
case int:
|
||||
if d < math.MinInt16 || d > math.MaxInt16 {
|
||||
return
|
||||
}
|
||||
v = int16(d)
|
||||
case uint:
|
||||
if d > math.MaxInt16 {
|
||||
return
|
||||
}
|
||||
v = int16(d)
|
||||
case int32:
|
||||
if d < math.MinInt16 || d > math.MaxInt16 {
|
||||
return
|
||||
}
|
||||
v = int16(d)
|
||||
case uint32:
|
||||
if d > math.MaxInt16 {
|
||||
return
|
||||
}
|
||||
v = int16(d)
|
||||
case int64:
|
||||
if d < math.MinInt16 || d > math.MaxInt16 {
|
||||
return
|
||||
}
|
||||
v = int16(d)
|
||||
case uint64:
|
||||
if d > math.MaxInt16 {
|
||||
return
|
||||
}
|
||||
v = int16(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToUint16(x interface{}) (ok bool, v uint16) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
case uint8:
|
||||
v = uint16(d)
|
||||
case int16:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
case uint16:
|
||||
v = d
|
||||
case int:
|
||||
if d < 0 || d > math.MaxUint16 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
case uint:
|
||||
if v > math.MaxUint16 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
case int32:
|
||||
if d < 0 || d > math.MaxUint16 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
case uint32:
|
||||
if d > math.MaxUint16 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
case int64:
|
||||
if d < 0 || d > math.MaxUint16 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
case uint64:
|
||||
if d > math.MaxUint16 {
|
||||
return
|
||||
}
|
||||
v = uint16(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToInt32(x interface{}) (ok bool, v int32) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
v = int32(d)
|
||||
case uint8:
|
||||
v = int32(d)
|
||||
case int16:
|
||||
v = int32(d)
|
||||
case uint16:
|
||||
v = int32(d)
|
||||
case int:
|
||||
v = int32(d)
|
||||
case uint:
|
||||
v = int32(d)
|
||||
case int32:
|
||||
v = d
|
||||
case uint32:
|
||||
if d > math.MaxInt32 {
|
||||
return
|
||||
}
|
||||
v = int32(d)
|
||||
case int64:
|
||||
if d < math.MinInt32 || d > math.MaxInt32 {
|
||||
return
|
||||
}
|
||||
v = int32(d)
|
||||
case uint64:
|
||||
if d > math.MaxInt32 {
|
||||
return
|
||||
}
|
||||
v = int32(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToUint32(x interface{}) (ok bool, v uint32) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint32(d)
|
||||
case uint8:
|
||||
v = uint32(d)
|
||||
case int16:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint32(d)
|
||||
case uint16:
|
||||
v = uint32(d)
|
||||
case int:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint32(d)
|
||||
case uint:
|
||||
v = uint32(d)
|
||||
case int32:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint32(d)
|
||||
case uint32:
|
||||
v = d
|
||||
case int64:
|
||||
if d < 0 || d > math.MaxUint32 {
|
||||
return
|
||||
}
|
||||
v = uint32(d)
|
||||
case uint64:
|
||||
if d > math.MaxInt32 {
|
||||
return
|
||||
}
|
||||
v = uint32(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToInt64(x interface{}) (ok bool, v int64) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
v = int64(d)
|
||||
case uint8:
|
||||
v = int64(d)
|
||||
case int16:
|
||||
v = int64(d)
|
||||
case uint16:
|
||||
v = int64(d)
|
||||
case int:
|
||||
v = int64(d)
|
||||
case uint:
|
||||
v = int64(d)
|
||||
case int32:
|
||||
v = int64(d)
|
||||
case uint32:
|
||||
v = int64(d)
|
||||
case int64:
|
||||
v = d
|
||||
case uint64:
|
||||
if d > math.MaxInt64 {
|
||||
return
|
||||
}
|
||||
v = int64(d)
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToUint64(x interface{}) (ok bool, v uint64) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = 1
|
||||
} else {
|
||||
v = 0
|
||||
}
|
||||
case int8:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint64(d)
|
||||
case uint8:
|
||||
v = uint64(d)
|
||||
case int16:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint64(d)
|
||||
case uint16:
|
||||
v = uint64(d)
|
||||
case int:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint64(d)
|
||||
case uint:
|
||||
v = uint64(d)
|
||||
case int32:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint64(d)
|
||||
case uint32:
|
||||
v = uint64(d)
|
||||
case int64:
|
||||
if d < 0 {
|
||||
return
|
||||
}
|
||||
v = uint64(d)
|
||||
case uint64:
|
||||
v = d
|
||||
default:
|
||||
return false, 0
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
|
||||
func convertToIntString(x interface{}) (ok bool, v string) {
|
||||
switch d := x.(type) {
|
||||
case bool:
|
||||
if d == true {
|
||||
v = fmt.Sprintf("1")
|
||||
} else {
|
||||
v = fmt.Sprintf("0")
|
||||
}
|
||||
case int8:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case uint8:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case int16:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case uint16:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case int:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case uint:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case int32:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case uint32:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case int64:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case uint64:
|
||||
v = fmt.Sprintf("%d", d)
|
||||
case float32:
|
||||
v = fmt.Sprintf("%f", d)
|
||||
case float64:
|
||||
v = fmt.Sprintf("%f", d)
|
||||
default:
|
||||
return false, ""
|
||||
}
|
||||
return true, v
|
||||
}
|
||||
Reference in New Issue
Block a user