wrapper/any.go

// Package wrapper ...
//
// Description : wrapper ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 2023-06-01 18:18
package wrapper

import (
	"fmt"
	"git.zhangdeman.cn/zhangdeman/consts"
	"git.zhangdeman.cn/zhangdeman/serialize"
	"reflect"
)

// AnyDataType ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:19 2023/6/1
func AnyDataType(data any) *AnyType {
	at := &AnyType{
		data: data,
	}
	at.dataType = at.Type()
	return at
}

// AnyType ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:19 2023/6/1
type AnyType struct {
	data     any
	dataType string
}

// IsNil 是否为 nil
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:21 2023/6/1
func (at *AnyType) IsNil() bool {
	if at.data == nil {
		return true
	}
	reflectValue := reflect.ValueOf(at.data)
	switch reflectValue.Kind() {
	case reflect.Chan, reflect.Func, reflect.Map,
		reflect.Pointer, reflect.UnsafePointer,
		reflect.Interface, reflect.Slice:
		return reflectValue.IsNil()
	default:
		return false
	}
}

// Type 获取类型
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:22 2023/6/1
func (at *AnyType) Type() string {
	if len(at.dataType) > 0 {
		// 已经处理过的,无需在处理
		return at.dataType
	}
	if at.IsNil() {
		return consts.DataTypeNil
	}
	reflectType := reflect.TypeOf(at.data)
	switch reflectType.Kind() {
	case reflect.String:
		return consts.DataTypeString
	case reflect.Slice, reflect.Array:
		return consts.DataTypeSliceAny
	case reflect.Map, reflect.Struct:
		return consts.DataTypeMapAnyAny
	case reflect.Pointer:
		return consts.DataTypePtr
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return consts.DataTypeInt
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return consts.DataTypeUint
	case reflect.Bool:
		return consts.DataTypeBool
	case reflect.Float32, reflect.Float64:
		return consts.DataTypeFloat
	default:
		return consts.DataTypeUnknown
	}
}

// ToString 转为字符串
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:32 2023/6/1
func (at *AnyType) ToString() String {
	dataType := at.Type()
	switch dataType {
	case consts.DataTypeUnknown, consts.DataTypeNil:
		return String("")
	case consts.DataTypeString:
		return String(fmt.Sprintf("%v", at.data))
	case consts.DataTypeSliceAny:
		var val []any
		_ = serialize.JSON.Transition(at.data, &val)
		return String(ArrayType[any](val).ToString().Value)
	case consts.DataTypeMapAnyAny:
		return String(EasyMap(at.data).ToString())
	case consts.DataTypeInt:
		return String(Int(at.data.(int64)).ToString().Value)
	case consts.DataTypeUint:
		return String(Int(at.data.(uint)).ToString().Value)
	case consts.DataTypeFloat:
		return String(Float(at.data.(float64)).ToString().Value)
	case consts.DataTypeBool:
		return String(fmt.Sprintf("%v", at.data))
	default:
		return String(serialize.JSON.MarshalForStringIgnoreError(at.data))
	}
}