123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397 |
- package reflectutils
- import (
- "github.com/pkg/errors"
- "reflect"
- "strconv"
- )
- func GroupValueKind(v reflect.Value) reflect.Kind {
- kind := v.Kind()
- switch {
- case kind >= reflect.Int && kind <= reflect.Int64:
- return reflect.Int64
- case kind >= reflect.Uint && kind <= reflect.Uint64:
- return reflect.Uint64
- case kind >= reflect.Float32 && kind <= reflect.Float64:
- return reflect.Float64
- default:
- return kind
- }
- }
- func PointerValueElem(v reflect.Value) reflect.Value {
- elem := v
- if v.Kind() == reflect.Ptr {
- elem = v.Elem()
- }
- return elem
- }
- func SliceValueElem(v reflect.Value) reflect.Value {
- elem := v
- if v.Kind() == reflect.Slice {
- elem = v.Elem()
- }
- return elem
- }
- func IsSliceValueOf(v reflect.Value, elementKind reflect.Kind) bool {
- return v.Kind() == reflect.Slice && v.Type().Elem().Kind() == elementKind
- }
- func IsValueInteger(v reflect.Value) bool {
- return v.Kind() >= reflect.Int && v.Kind() <= reflect.Int64
- }
- func IsValueUnsignedInteger(v reflect.Value) bool {
- return v.Kind() >= reflect.Uint && v.Kind() <= reflect.Uint64
- }
- func IsValueFloat(v reflect.Value) bool {
- return v.Kind() >= reflect.Float32 && v.Kind() <= reflect.Float64
- }
- func IsValueStructPointer(v reflect.Value) bool {
- return v.Kind() == reflect.Pointer && v.Elem().Kind() == reflect.Struct
- }
- func IsValueStructOrStructPointer(v reflect.Value) bool {
- return v.Kind() == reflect.Struct || IsValueStructPointer(v)
- }
- func IsValueStructSliceOrStructSlicePointer(v reflect.Value) bool {
- return IsSliceValueOf(v, reflect.Struct) || (v.Kind() == reflect.Pointer && IsSliceValueOf(v.Elem(), reflect.Struct))
- }
- func IsValueTime(v reflect.Value) bool {
- return v.Kind() == reflect.Struct && v.Type().String() == "time.Time"
- }
- func IsValueTimePointer(v reflect.Value) bool {
- return v.Kind() == reflect.Pointer && IsValueTime(v.Elem())
- }
- func AssignStringValue(data any, val reflect.Value) error {
- if data == nil {
- return nil
- }
- if val.Kind() != reflect.String {
- return errors.New("val应当为string类型的Value")
- }
- v, err := ToString(data)
- if err != nil {
- return err
- }
- val.SetString(v)
- return nil
- }
- func AssignInt64Value(data any, val reflect.Value) error {
- if data == nil {
- return nil
- }
- if val.Kind() < reflect.Int && val.Kind() > reflect.Int64 {
- return errors.New("val应当为int类型的Value")
- }
- v, err := ToInt64(data)
- if err != nil {
- return err
- }
- val.SetInt(v)
- return nil
- }
- func AssignUint64Value(data any, val reflect.Value) error {
- if data == nil {
- return nil
- }
- if val.Kind() < reflect.Uint && val.Kind() > reflect.Uint64 {
- return errors.New("val应当为uint类型的Value")
- }
- v, err := ToUint64(data)
- if err != nil {
- return err
- }
- val.SetUint(v)
- return nil
- }
- func AssignBoolValue(data any, val reflect.Value) error {
- if data == nil {
- return nil
- }
- if val.Kind() != reflect.Bool {
- return errors.New("val应当为bool类型的Value")
- }
- v, err := ToBool(data)
- if err != nil {
- return err
- }
- val.SetBool(v)
- return nil
- }
- func AssignFloat64Value(data any, val reflect.Value) error {
- if data == nil {
- return nil
- }
- if val.Kind() != reflect.Float32 && val.Kind() != reflect.Float64 {
- return errors.New("val应当为float类型的Value")
- }
- v, err := ToFloat64(data)
- if err != nil {
- return err
- }
- val.SetFloat(v)
- return nil
- }
- func ToString(data any) (string, error) {
- if data == nil {
- return "", nil
- }
- dataVal := reflect.Indirect(reflect.ValueOf(data))
- dataKind := GroupValueKind(dataVal)
- switch dataKind {
- case reflect.String:
- return dataVal.String(), nil
- case reflect.Bool:
- if dataVal.Bool() {
- return "1", nil
- } else {
- return "0", nil
- }
- case reflect.Int64:
- return strconv.FormatInt(dataVal.Int(), 10), nil
- case reflect.Uint64:
- return strconv.FormatUint(dataVal.Uint(), 10), nil
- case reflect.Float64:
- return strconv.FormatFloat(dataVal.Float(), 'f', -1, 64), nil
- case reflect.Slice, reflect.Array:
- elemKind := dataVal.Type().Elem().Kind()
- if elemKind != reflect.Uint8 {
- return "", errors.New("不支持的类型: " + dataVal.Type().String())
- }
- var uints []uint8
- if dataKind == reflect.Array {
- uints = make([]uint8, dataVal.Len(), dataVal.Len())
- for i := range uints {
- uints[i] = dataVal.Index(i).Interface().(uint8)
- }
- } else {
- uints = dataVal.Interface().([]uint8)
- }
- return string(uints), nil
- default:
- return "", errors.New("不支持的类型: " + dataVal.Type().String())
- }
- }
- func ToInt64(data any) (int64, error) {
- if data == nil {
- return 0, nil
- }
- dataVal := reflect.Indirect(reflect.ValueOf(data))
- dataKind := GroupValueKind(dataVal)
- switch dataKind {
- case reflect.Int64:
- return dataVal.Int(), nil
- case reflect.Uint64:
- return int64(dataVal.Uint()), nil
- case reflect.Float64:
- return int64(dataVal.Float()), nil
- case reflect.Bool:
- if dataVal.Bool() {
- return 1, nil
- } else {
- return 0, nil
- }
- case reflect.String:
- str := dataVal.String()
- if str == "" {
- str = "0"
- }
- return strconv.ParseInt(str, 0, 10)
- default:
- return 0, errors.New("不支持的类型: " + dataVal.Type().String())
- }
- }
- func ToUint64(data any) (uint64, error) {
- if data == nil {
- return 0, nil
- }
- dataVal := reflect.Indirect(reflect.ValueOf(data))
- dataKind := GroupValueKind(dataVal)
- switch dataKind {
- case reflect.Int64:
- return uint64(dataVal.Int()), nil
- case reflect.Uint64:
- return dataVal.Uint(), nil
- case reflect.Float64:
- return uint64(dataVal.Float()), nil
- case reflect.Bool:
- if dataVal.Bool() {
- return 1, nil
- } else {
- return 0, nil
- }
- case reflect.String:
- str := dataVal.String()
- if str == "" {
- str = "0"
- }
- return strconv.ParseUint(str, 0, 10)
- default:
- return 0, errors.New("不支持的类型: " + dataVal.Type().String())
- }
- }
- func ToBool(data any) (bool, error) {
- if data == nil {
- return false, nil
- }
- dataVal := reflect.Indirect(reflect.ValueOf(data))
- dataKind := GroupValueKind(dataVal)
- switch dataKind {
- case reflect.Bool:
- return dataVal.Bool(), nil
- case reflect.Int64:
- return dataVal.Int() != 0, nil
- case reflect.Uint64:
- return dataVal.Uint() != 0, nil
- case reflect.Float64:
- return dataVal.Float() != 0, nil
- case reflect.String:
- if dataVal.String() == "" {
- return false, nil
- } else {
- return strconv.ParseBool(dataVal.String())
- }
- default:
- return false, errors.New("不支持的类型: " + dataVal.Type().String())
- }
- }
- func ToFloat64(data any) (float64, error) {
- if data == nil {
- return 0, nil
- }
- dataVal := reflect.Indirect(reflect.ValueOf(data))
- dataKind := GroupValueKind(dataVal)
- switch dataKind {
- case reflect.Int64:
- return float64(dataVal.Int()), nil
- case reflect.Uint64:
- return float64(dataVal.Uint()), nil
- case reflect.Float64:
- return dataVal.Float(), nil
- case reflect.Bool:
- if dataVal.Bool() {
- return 1, nil
- } else {
- return 0, nil
- }
- case reflect.String:
- str := dataVal.String()
- if str == "" {
- str = "0"
- }
- return strconv.ParseFloat(str, 10)
- default:
- return 0, errors.New("不支持的类型: " + dataVal.Type().String())
- }
- }
- func Zero[T any]() T {
- var zeroT T
- zeroAnyValue := reflect.ValueOf(zeroT)
- zeroAny := ZeroValueToAny(zeroAnyValue)
- if zeroAny == nil {
- return zeroT
- }
- return zeroAny.(T)
- }
- func ZeroValueToAny(v reflect.Value) any {
- if v.Kind() == reflect.Invalid {
- return nil
- }
- zeroValue := reflect.New(v.Type()).Elem()
- if zeroValue.Kind() != reflect.Pointer {
- zero(&zeroValue)
- return zeroValue.Interface()
- }
- zeroValue.Set(reflect.New(zeroValue.Type().Elem()))
- elemValue := PointerValueElem(zeroValue)
- zero(&elemValue)
- return zeroValue.Interface()
- }
- func zero(v *reflect.Value) {
- if v.Kind() == reflect.Slice || v.Kind() == reflect.Array {
- v.Set(reflect.MakeSlice(v.Type(), 0, 0))
- } else if v.Kind() == reflect.Map {
- v.Set(reflect.MakeMap(v.Type()))
- } else if v.Kind() == reflect.Chan {
- v.Set(reflect.MakeChan(v.Type(), 0))
- } else {
- v.Set(reflect.New(v.Type()).Elem())
- }
- }
|