568 lines
13 KiB
Go
568 lines
13 KiB
Go
package ssob
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"reflect"
|
|
|
|
"gitea.olznet.de/OlzNet/slog"
|
|
)
|
|
|
|
type allocatorFunc func(vals ...interface{}) interface{}
|
|
type marshallerFunc func(interface{}, io.Writer) error
|
|
type unmarshallerFunc func(io.Reader) (interface{}, error)
|
|
|
|
type marshalFunc func(interface{}) ([]byte, error)
|
|
type nallocFunc func() interface{}
|
|
|
|
type RegisteredTypes struct {
|
|
NextId uint32
|
|
ntypes map[uint32]*NType
|
|
nnames map[string]*NType
|
|
}
|
|
|
|
const (
|
|
ST_COMMON = 0
|
|
ST_SLICE = 1
|
|
ST_ARRAY = 2
|
|
ST_STRUCT = 3
|
|
ST_MAP = 4
|
|
//ST_MINTERFACE = 5
|
|
)
|
|
|
|
type StructField struct {
|
|
Id uint32
|
|
Name string
|
|
Tag string
|
|
SId int
|
|
}
|
|
|
|
type NType struct {
|
|
Name string
|
|
Id uint32
|
|
Indirection int
|
|
MainTypeId uint32
|
|
ValType uint32
|
|
structFields []*StructField
|
|
arrayLen int
|
|
alloc nallocFunc
|
|
}
|
|
|
|
type Type struct {
|
|
Name string
|
|
Id uint32
|
|
alloc allocatorFunc
|
|
marshal marshallerFunc
|
|
unmarshal unmarshallerFunc
|
|
}
|
|
|
|
type baseType struct {
|
|
}
|
|
|
|
var cacheTypes RegisteredTypes
|
|
|
|
const (
|
|
ST_ID_SIZE = 4
|
|
)
|
|
|
|
const (
|
|
ST_INVALID = 0
|
|
ST_BOOL = 1
|
|
ST_UINT8 = 2
|
|
ST_UINT16 = 3
|
|
ST_UINT32 = 4
|
|
ST_UINT64 = 5
|
|
ST_INT8 = 6
|
|
ST_INT16 = 7
|
|
ST_INT32 = 8
|
|
ST_INT64 = 9
|
|
ST_FLOAT32 = 10
|
|
ST_FLOAT64 = 11
|
|
ST_STRING = 12
|
|
ST_ERROR = 13
|
|
ST_NIL = 14
|
|
ST_INTERFACE = 15
|
|
)
|
|
|
|
func init() {
|
|
cacheTypes.NextId = 128
|
|
cacheTypes.ntypes = make(map[uint32]*NType)
|
|
cacheTypes.nnames = make(map[string]*NType)
|
|
|
|
boolType := &NType{
|
|
"bool", ST_BOOL, 0, ST_COMMON, ST_BOOL, nil,
|
|
0, func() interface{} { return new(bool) },
|
|
}
|
|
cacheTypes.ntypes[ST_BOOL] = boolType
|
|
cacheTypes.nnames["bool"] = boolType
|
|
|
|
uint8Type := &NType{
|
|
"uint8", ST_UINT8, 0, ST_COMMON, ST_UINT8, nil,
|
|
0, func() interface{} { return new(uint8) },
|
|
}
|
|
cacheTypes.ntypes[ST_UINT8] = uint8Type
|
|
cacheTypes.nnames["uint8"] = uint8Type
|
|
|
|
uint16Type := &NType{
|
|
"uint16", ST_UINT16, 0, ST_COMMON, ST_UINT16, nil,
|
|
0, func() interface{} { return new(uint16) },
|
|
}
|
|
cacheTypes.ntypes[ST_UINT16] = uint16Type
|
|
cacheTypes.nnames["uint16"] = uint16Type
|
|
|
|
uint32Type := &NType{
|
|
"uint32", ST_UINT32, 0, ST_COMMON, ST_UINT32, nil,
|
|
0, func() interface{} { return new(uint32) },
|
|
}
|
|
cacheTypes.ntypes[ST_UINT32] = uint32Type
|
|
cacheTypes.nnames["uint32"] = uint32Type
|
|
|
|
uint64Type := &NType{
|
|
"uint64", ST_UINT64, 0, ST_COMMON, ST_UINT64, nil,
|
|
0, func() interface{} { return new(uint64) },
|
|
}
|
|
cacheTypes.ntypes[ST_UINT64] = uint64Type
|
|
cacheTypes.nnames["uint64"] = uint64Type
|
|
|
|
int8Type := &NType{
|
|
"int8", ST_INT8, 0, ST_COMMON, ST_INT8, nil,
|
|
0, func() interface{} { return new(int8) },
|
|
}
|
|
cacheTypes.ntypes[ST_INT8] = int8Type
|
|
cacheTypes.nnames["int8"] = int8Type
|
|
|
|
int16Type := &NType{
|
|
"int16", ST_INT16, 0, ST_COMMON, ST_INT16, nil,
|
|
0, func() interface{} { return new(int16) },
|
|
}
|
|
cacheTypes.ntypes[ST_INT16] = int16Type
|
|
cacheTypes.nnames["int16"] = int16Type
|
|
|
|
int32Type := &NType{
|
|
"int32", ST_INT32, 0, ST_COMMON, ST_INT32, nil,
|
|
0, func() interface{} { return new(int32) },
|
|
}
|
|
cacheTypes.ntypes[ST_INT32] = int32Type
|
|
cacheTypes.nnames["int32"] = int32Type
|
|
|
|
int64Type := &NType{
|
|
"int64", ST_INT64, 0, ST_COMMON, ST_INT64, nil,
|
|
0, func() interface{} { return new(int64) },
|
|
}
|
|
cacheTypes.ntypes[ST_INT64] = int64Type
|
|
cacheTypes.nnames["int64"] = int64Type
|
|
|
|
float32Type := &NType{
|
|
"float32", ST_FLOAT32, 0, ST_COMMON, ST_FLOAT32, nil,
|
|
0, func() interface{} { return new(float32) },
|
|
}
|
|
cacheTypes.ntypes[ST_FLOAT32] = float32Type
|
|
cacheTypes.nnames["float32"] = float32Type
|
|
|
|
float64Type := &NType{
|
|
"float64", ST_FLOAT64, 0, ST_COMMON, ST_FLOAT64, nil,
|
|
0, func() interface{} { return new(float64) },
|
|
}
|
|
cacheTypes.ntypes[ST_FLOAT64] = float64Type
|
|
cacheTypes.nnames["float64"] = float64Type
|
|
|
|
stringType := &NType{
|
|
"string", ST_STRING, 0, ST_COMMON, ST_STRING, nil,
|
|
0, func() interface{} { return new(string) },
|
|
}
|
|
cacheTypes.ntypes[ST_STRING] = stringType
|
|
cacheTypes.nnames["string"] = stringType
|
|
|
|
errorType := &NType{
|
|
"error", ST_ERROR, 0, ST_COMMON, ST_ERROR, nil,
|
|
0, func() interface{} { return new(error) },
|
|
}
|
|
cacheTypes.ntypes[ST_ERROR] = errorType
|
|
cacheTypes.nnames["error"] = errorType
|
|
|
|
nilType := &NType{
|
|
"nil", ST_NIL, 0, ST_NIL, ST_NIL, nil,
|
|
0, func() interface{} { return nil },
|
|
}
|
|
cacheTypes.ntypes[ST_NIL] = nilType
|
|
cacheTypes.nnames["nil"] = nilType
|
|
|
|
interfaceType := &NType{
|
|
"interface {}", ST_INTERFACE, 0, ST_INTERFACE, ST_INTERFACE, nil,
|
|
0, func() interface{} { return new(interface{}) },
|
|
}
|
|
cacheTypes.ntypes[ST_INTERFACE] = interfaceType
|
|
cacheTypes.nnames["interface {}"] = interfaceType
|
|
}
|
|
|
|
func getTypeById(id uint32) (ret *NType) {
|
|
if ret, ok := cacheTypes.ntypes[id]; !ok {
|
|
return nil
|
|
} else {
|
|
return ret
|
|
}
|
|
}
|
|
|
|
func getTypeByName(name string) (ret *NType) {
|
|
if ret, ok := cacheTypes.nnames[name]; !ok {
|
|
return nil
|
|
} else {
|
|
return ret
|
|
}
|
|
}
|
|
|
|
func parseType(t reflect.Type) (ret nallocFunc, mainTypeId uint32, indirection int, valType uint32, base bool, sfields []*StructField, arrayLen int, err error) {
|
|
indirection = 0
|
|
ret = func() interface{} {
|
|
vret := reflect.New(t)
|
|
val := vret.Elem()
|
|
|
|
for {
|
|
if val.Kind() == reflect.Ptr {
|
|
val.Set(reflect.New(val.Type().Elem()))
|
|
val = val.Elem()
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
//return vret
|
|
return vret.Interface()
|
|
}
|
|
|
|
sfields = []*StructField{}
|
|
arrayLen = 0
|
|
vret := reflect.New(t)
|
|
val := vret.Elem()
|
|
nval := vret
|
|
|
|
base = true
|
|
|
|
for {
|
|
if val.Kind() == reflect.Ptr {
|
|
nval = nval.Elem()
|
|
val.Set(reflect.New(val.Type().Elem()))
|
|
val = val.Elem()
|
|
indirection += 1
|
|
base = false
|
|
} else {
|
|
switch val.Kind() {
|
|
case reflect.Slice:
|
|
typ := reflect.TypeOf(val.Interface())
|
|
vt, err := getTypeByNameRegister(typ.Elem().String(), typ.Elem())
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
valType = vt.Id
|
|
base = false
|
|
mainTypeId = ST_SLICE
|
|
case reflect.Array:
|
|
typ := reflect.TypeOf(val.Interface())
|
|
arrayLen = val.Len()
|
|
vt, err := getTypeByNameRegister(typ.Elem().String(), typ.Elem())
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
valType = vt.Id
|
|
base = false
|
|
mainTypeId = ST_ARRAY
|
|
case reflect.Struct:
|
|
typ := reflect.TypeOf(val.Interface())
|
|
if !base {
|
|
vt, err := getTypeByNameRegister(typ.String(), typ)
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
valType = vt.Id
|
|
} else {
|
|
sl := val.NumField()
|
|
for i := 0; i < sl; i++ {
|
|
if val.Field(i).CanSet() {
|
|
sfield := new(StructField)
|
|
sfield.Name = val.Type().Field(i).Name
|
|
sfield.Tag = string(val.Type().Field(i).Tag)
|
|
slog.LOG_DEBUGFLN("ts: %v", val.Field(i).Type().String())
|
|
slog.LOG_DEBUGFLN("tt: %v", val.Field(i).Type())
|
|
vt, err := getTypeByNameRegister(val.Field(i).Type().String(), val.Field(i).Type())
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
sfield.Id = vt.Id
|
|
sfield.SId = i
|
|
sfields = append(sfields, sfield)
|
|
}
|
|
}
|
|
base = true
|
|
}
|
|
mainTypeId = ST_STRUCT
|
|
case reflect.Map:
|
|
typ := reflect.TypeOf(val.Interface())
|
|
if !base {
|
|
vt, err := getTypeByNameRegister(typ.String(), typ)
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
valType = vt.Id
|
|
} else {
|
|
// Key
|
|
vt, err := getTypeByNameRegister(typ.Key().String(), typ.Key())
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
valType = vt.Id
|
|
|
|
// Val
|
|
vt, err = getTypeByNameRegister(typ.Elem().String(), typ.Elem())
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
valType = vt.Id
|
|
base = false
|
|
}
|
|
mainTypeId = ST_MAP
|
|
default:
|
|
typ := reflect.TypeOf(val.Interface())
|
|
if !base {
|
|
vt, err := getTypeByNameRegister(typ.Kind().String(), typ)
|
|
if err != nil {
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
valType = vt.Id
|
|
}
|
|
mainTypeId = ST_COMMON
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
return ret, mainTypeId, indirection, valType, base, sfields, arrayLen, err
|
|
}
|
|
|
|
func getTypeByNameRegister(name string, t reflect.Type) (ret *NType, err error) {
|
|
if ret = getTypeByName(name); ret != nil {
|
|
return ret, err
|
|
}
|
|
|
|
if err = registerType(t); err != nil {
|
|
return ret, err
|
|
}
|
|
|
|
if ret = getTypeByName(name); ret == nil {
|
|
return ret, fmt.Errorf("ssob: Failed registering type '%s'", name)
|
|
}
|
|
|
|
return ret, err
|
|
}
|
|
|
|
func createType(t reflect.Type) (ret *NType, base bool, err error) {
|
|
if t == nil {
|
|
return ret, base, fmt.Errorf("ssob: Cannot create Type from nil: %w", ErrTypeInvalid)
|
|
}
|
|
|
|
ret = new(NType)
|
|
ret.Name = t.String()
|
|
ret.alloc, ret.MainTypeId, ret.Indirection, ret.ValType, base, ret.structFields, ret.arrayLen, err = parseType(t)
|
|
|
|
return ret, base, err
|
|
}
|
|
|
|
func registerType(t reflect.Type) (err error) {
|
|
if t == nil || t.Kind() == reflect.Invalid {
|
|
return ErrTypeInvalid
|
|
}
|
|
|
|
if getTypeByName(t.String()) != nil {
|
|
return nil
|
|
}
|
|
|
|
var base bool
|
|
ntype, base, err := createType(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ntype.Id = cacheTypes.NextId
|
|
if base {
|
|
ntype.ValType = ntype.Id
|
|
}
|
|
cacheTypes.ntypes[ntype.Id] = ntype
|
|
cacheTypes.nnames[ntype.Name] = ntype
|
|
cacheTypes.NextId += 1
|
|
|
|
return err
|
|
}
|
|
|
|
func splitType(e interface{}) (t reflect.Type, v reflect.Value, err error) {
|
|
t = reflect.TypeOf(e)
|
|
if t == nil || t.Kind() != reflect.Ptr {
|
|
return t, v, ErrTypeInvalid
|
|
}
|
|
|
|
v = reflect.ValueOf(e)
|
|
if v.IsNil() {
|
|
return t, v, ErrValueInvalid
|
|
}
|
|
|
|
return t, v, err
|
|
}
|
|
|
|
func indirectType(e interface{}) (ret interface{}, ntype *NType, nilLevel uint16, err error) {
|
|
nilLevel = 0
|
|
|
|
t, v, err := splitType(e)
|
|
if err != nil {
|
|
return nil, nil, nilLevel, err
|
|
}
|
|
|
|
ntype, err = getTypeByNameRegister(t.Elem().String(), t.Elem())
|
|
if err != nil {
|
|
return nil, nil, nilLevel, err
|
|
}
|
|
|
|
for i := 0; i < ntype.Indirection; i++ {
|
|
if v, err = indirectValue(v); err != nil {
|
|
return nil, ntype, nilLevel, ErrValueInvalid
|
|
}
|
|
if v.IsValid() && v.IsNil() {
|
|
nilLevel += uint16(i)
|
|
return nil, ntype, nilLevel, err
|
|
}
|
|
}
|
|
|
|
if v, err = indirectValue(v); err != nil {
|
|
return nil, ntype, nilLevel, err
|
|
}
|
|
|
|
return v.Interface(), ntype, nilLevel, err
|
|
}
|
|
|
|
func setTypeNil(e interface{}, indirection int) (err error) {
|
|
var v reflect.Value
|
|
|
|
if v, err = getValPtr(e); err != nil {
|
|
return err
|
|
}
|
|
|
|
if v, err = indirectValue(v); err != nil {
|
|
if indirection > 0 {
|
|
return ErrValueInvalid
|
|
}
|
|
}
|
|
|
|
for i := 0; i < indirection; i++ {
|
|
if v, err = indirectValue(v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.IsValid() && !v.IsNil() {
|
|
v.Set(reflect.Zero(reflect.TypeOf(v.Interface())))
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func setTypeVal(e interface{}, val interface{}, ntype *NType) (err error) {
|
|
var v reflect.Value
|
|
|
|
if v, err = getValPtr(e); err != nil {
|
|
return err
|
|
}
|
|
if v, err = indirectValue(v); err != nil {
|
|
return err
|
|
}
|
|
for i := 0; i < ntype.Indirection; i++ {
|
|
if v, err = indirectValue(v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
v.Set(reflect.ValueOf(val))
|
|
return err
|
|
}
|
|
|
|
func getValPtr(e interface{}) (ret reflect.Value, err error) {
|
|
v := reflect.ValueOf(e)
|
|
|
|
if !v.IsValid() || v.Kind() != reflect.Ptr || v.IsNil() {
|
|
err = ErrValueInvalid
|
|
}
|
|
|
|
return v, err
|
|
}
|
|
|
|
func getVal(e interface{}) (ret reflect.Value) {
|
|
v := reflect.ValueOf(e)
|
|
|
|
if !v.IsValid() || v.Kind() != reflect.Ptr || v.IsNil() {
|
|
return v
|
|
}
|
|
return reflect.Indirect(v)
|
|
}
|
|
|
|
func indirectValue(v reflect.Value) (ret reflect.Value, err error) {
|
|
if !v.IsValid() || v.Kind() != reflect.Ptr {
|
|
return v, ErrValueInvalid
|
|
}
|
|
|
|
ret = reflect.Indirect(v)
|
|
return ret, err
|
|
}
|
|
|
|
func valueIsNil(v reflect.Value) (ret bool) {
|
|
ret = false
|
|
|
|
if !v.IsValid() || v.Kind() == reflect.Invalid || (v.Kind() == reflect.Ptr && v.IsNil()) {
|
|
ret = true
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func traverseValuePtr(v reflect.Value) (ret reflect.Value) {
|
|
ret = v
|
|
if !ret.IsValid() || ret.Kind() != reflect.Ptr {
|
|
return ret
|
|
} else {
|
|
ret = reflect.Indirect(ret)
|
|
return traverseValuePtr(ret)
|
|
}
|
|
}
|
|
|
|
func parseInterface(e interface{}) (rett reflect.Type, retv reflect.Value, err error) {
|
|
t := reflect.TypeOf(e)
|
|
|
|
if t == nil || t.Kind() != reflect.Ptr {
|
|
return nil, reflect.ValueOf(e), ErrTypeInvalid
|
|
}
|
|
|
|
if t.Elem().Kind() == reflect.Interface {
|
|
rett = reflect.TypeOf(reflect.Indirect(reflect.ValueOf(e)).Interface())
|
|
|
|
retv = reflect.New(rett)
|
|
retv.Elem().Set(reflect.ValueOf(reflect.Indirect(reflect.ValueOf(e)).Interface()))
|
|
slog.LOG_DEBUGFLN("rett: %v", rett)
|
|
slog.LOG_DEBUGFLN("retv: %v", retv)
|
|
return rett, retv, nil
|
|
}
|
|
|
|
slog.LOG_DEBUGFLN("t: %v", t)
|
|
slog.LOG_DEBUGFLN("v: %v", reflect.ValueOf(e))
|
|
return t, reflect.ValueOf(e), nil
|
|
}
|
|
|
|
func RegisterType(e interface{}) (err error) {
|
|
//t := reflect.TypeOf(e)
|
|
t, _, err := parseInterface(e)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if t == nil || t.Kind() != reflect.Ptr {
|
|
return fmt.Errorf("ssob: Interface is not a valid address: %w", ErrTypeInvalid)
|
|
}
|
|
|
|
if err = registerType(t.Elem()); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|