go
/
active
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: go:rev-packs
Branches Tags
go:rev-packs
go:master
..
compare: go:master
Branches Tags
go:rev-packs
go:master

No commits in common. 'rev-packs' and 'master' have entirely different histories.
rev-packs ... master

33 changed files with 768 additions and 687 deletions
Show Stats

3
alogs/active_logger.go
Unescape View File

@ -30,7 +30,6 @@ import (
"strings" "strings"
"sync" "sync"
"syncs/queue" "syncs/queue"
"vals/flds"
) )
type ( type (
@ -364,7 +363,7 @@ func (l *ActiveLogger) handleLoggers(entry *Entry, doFn func(c Logger, e *Entry)
if l.logErrors { if l.logErrors {
en = AcquireEntry(l,LevelError,ms,ne, en = AcquireEntry(l,LevelError,ms,ne,
EntryWithExclude (nm), EntryWithExclude (nm),
EntryWithFields (flds.NewAFieldString(entryFieldLogger,nm))) EntryWithField (entryFieldLogger,nm,true))
} }
l.handleError(ne,en,co) l.handleError(ne,en,co)
} }

29
alogs/entry.go
Unescape View File

@ -27,8 +27,6 @@ import (
"apacks" "apacks"
"atypes/slices" "atypes/slices"
"time" "time"
"vals/flds"
"vals/flds/pkflds"
) )
type ( type (
@ -47,7 +45,6 @@ type (
Error error Error error
Data any Data any
Fields flds.AFields
Excludes slices.Strings Excludes slices.Strings
} }
@ -105,11 +102,26 @@ func (e *Entry) reset () *Entry {
func (e *Entry) Clone() *Entry {
n := *e
/*
l:=len(e.Fields)
if l > 0 {
n.Fields = make(vals.Fields,len(e.Fields))
for i:=0; i<l; i++ {
n.Fields[i]=e.Fields[i]
}
}
*/
return &n
}
func (e *Entry) BuildPack(packer apacks.ValuePacker) error { func (e *Entry) BuildPack(packer apacks.ValuePacker) error {
packer.PackObject(func (b apacks.ObjectPackBuilder, _ apacks.Flags){ packer.PackObject(func (b apacks.ObjectPackBuilder, _ apacks.Flags){
b.FieldUInt64("id",e.Id,0) b.FieldUInt64("id",e.Id,0)
b.FieldDate("date",e.Date,0) b.FieldDate("date",e.Date,0)
pkflds.AddAFieldsToPack(b,e.Fields)
},0) },0)
return nil return nil
@ -139,16 +151,9 @@ func EntryWithExtender(extender EntryExtender) EntryFnc {
extender.ExtendEntry(e) } } extender.ExtendEntry(e) } }
func EntryWithField (name string, value any) EntryFnc { func EntryWithField (name string, value any, overwrite bool) EntryFnc {
return func(e *Entry) { return func(e *Entry) {
e.Fields = e.Fields.SetField(flds.NewAField(name,value)) }
}
func EntryWithFields (field ...flds.AField) EntryFnc {
return func(e *Entry) {
for _,f := range field {
e.Fields = e.Fields.SetField(f)
}
} }
} }

4
apacks/pkjson/active.go
Unescape View File

@ -54,13 +54,13 @@ var (
jsonMarshalerType reflect.Type jsonMarshalerType reflect.Type
textMarshalerType reflect.Type textMarshalerType reflect.Type
packMarshalerType reflect.Type packMarshalerType reflect.Type
packBuilderType reflect.Type
}{ }{
jsonMarshalerType: reflect.TypeOf((*json.Marshaler)(nil)).Elem(), jsonMarshalerType: reflect.TypeOf((*json.Marshaler)(nil)).Elem(),
textMarshalerType: reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem(), textMarshalerType: reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem(),
packMarshalerType: reflect.TypeOf((*apacks.Packer)(nil)).Elem(), packMarshalerType: reflect.TypeOf((*apacks.Packer)(nil)).Elem(),
packBuilderType : reflect.TypeOf((*apacks.PackBuilder)(nil)).Elem(),
} }
) )

284
apacks/pkjson/json_packer.go
Unescape View File

@ -31,8 +31,6 @@ import (
"errs" "errs"
"reflect" "reflect"
"time" "time"
"vals/flds"
"vals/flds/pkflds"
) )
@ -114,85 +112,81 @@ func (p *JSONPacker) PackAny (value any, flags apacks.Flags) {
p.state.W(d) p.state.W(d)
} }
case flds.AFields: case bool : packBool (p.state,v,flags )
p.state.SetError(pkflds.AFieldsListPacker(v).BuildPack(p))
case bool : packBool (p,v,flags ) case string : packString(p.state,v,flags )
case string : packString(p,v,flags ) case int : packInt(p.state,int64(v),flags)
case int8 : packInt(p.state,int64(v),flags)
case int16 : packInt(p.state,int64(v),flags)
case int32 : packInt(p.state,int64(v),flags)
case int64 : packInt(p.state,v,flags )
case int : packInt(p,int64(v),flags) case uint : packUInt(p.state,uint64(v),flags)
case int8 : packInt(p,int64(v),flags) case uint8 : packUInt(p.state,uint64(v),flags)
case int16 : packInt(p,int64(v),flags) case uint16 : packUInt(p.state,uint64(v),flags)
case int32 : packInt(p,int64(v),flags) case uint32 : packUInt(p.state,uint64(v),flags)
case int64 : packInt(p,v,flags ) case uint64 : packUInt(p.state,v,flags )
case uint : packUInt(p,uint64(v),flags) case float32: packFloatString(p.state,float64(v),flags,32)
case uint8 : packUInt(p,uint64(v),flags) case float64: packFloatString(p.state,v,flags,64)
case uint16 : packUInt(p,uint64(v),flags)
case uint32 : packUInt(p,uint64(v),flags)
case uint64 : packUInt(p,v,flags )
case float32: packFloatString(p,float64(v),flags,32) case time.Time: packDate (p.state,v,flags)
case float64: packFloatString(p,v,flags,64)
case time.Time: packDate (p,v,flags) case reflect.Value: rTypePacker(v.Type())(p.state,v,flags)
case reflect.Value: rTypePacker(v.Type())(p,v,flags)
case []uint8 : case []uint8 :
if flags.Binary() { if flags.Binary() {
packBinary(p,v,flags) packBinary(p.state,v,flags)
return return
} }
packListUInt[uint8 ](p,v,flags) packListUInt[uint8 ](p.state,v,flags)
case []uint : packListUInt [uint ] (p.state,v,flags)
case []uint : packListUInt [uint ] (p,v,flags) case []uint16 : packListUInt [uint16] (p.state,v,flags)
case []uint16 : packListUInt [uint16] (p,v,flags) case []uint32 : packListUInt [uint32] (p.state,v,flags)
case []uint32 : packListUInt [uint32] (p,v,flags) case []uint64 : packListUInt [uint64] (p.state,v,flags)
case []uint64 : packListUInt [uint64] (p,v,flags) case []int : packListInt [int ] (p.state,v,flags)
case []int : packListInt [int ] (p,v,flags) case []int8 : packListInt [int8 ] (p.state,v,flags)
case []int8 : packListInt [int8 ] (p,v,flags) case []int16 : packListInt [int16] (p.state,v,flags)
case []int16 : packListInt [int16] (p,v,flags) case []int32 : packListInt [int32] (p.state,v,flags)
case []int32 : packListInt [int32] (p,v,flags) case []int64 : packListInt [int64] (p.state,v,flags)
case []int64 : packListInt [int64] (p,v,flags) case []float32: packListFloat[float32](p.state,v,flags,32)
case []float32: packListFloat[float32](p,v,flags,32) case []float64: packListFloat[float64](p.state,v,flags,64)
case []float64: packListFloat[float64](p,v,flags,64)
case []bool : packListBool (p.state,v,flags)
case []bool : packListBool (p,v,flags) case []string : packListString(p.state,v,flags)
case []string : packListString(p,v,flags) case []time.Time: packListDate(p.state,v,flags)
case []time.Time: packListDate(p,v,flags)
default: default:
rv := reflect.ValueOf(value) rv := reflect.ValueOf(value)
rTypePacker(rv.Type())(p,rv,flags) rTypePacker(rv.Type())(p.state,rv,flags)
} }
} }
func (p *JSONPacker) PackRaw (value []byte, flags apacks.Flags) { packRaw(p,value,flags) } func (p *JSONPacker) PackRaw (value []byte, flags apacks.Flags) { packRaw(p.state,value,flags) }
func (p *JSONPacker) PackBinary (value []byte, flags apacks.Flags) { packBinary (p,value,flags) } func (p *JSONPacker) PackBinary (value []byte, flags apacks.Flags) { packBinary(p.state,value,flags) }
func (p *JSONPacker) PackString (value string, flags apacks.Flags) { packString (p,value,flags) } func (p *JSONPacker) PackString (value string, flags apacks.Flags) { packString (p.state,value,flags) }
func (p *JSONPacker) PackBool (value bool, flags apacks.Flags) { packBool(p,value,flags) } func (p *JSONPacker) PackBool (value bool, flags apacks.Flags) { packBool(p.state,value,flags) }
func (p *JSONPacker) PackInt8 (value int8 , flags apacks.Flags) { packInt(p,int64(value),flags) } func (p *JSONPacker) PackInt8 (value int8 , flags apacks.Flags) { packInt(p.state,int64(value),flags) }
func (p *JSONPacker) PackInt16 (value int16, flags apacks.Flags) { packInt(p,int64(value),flags) } func (p *JSONPacker) PackInt16 (value int16, flags apacks.Flags) { packInt(p.state,int64(value),flags) }
func (p *JSONPacker) PackInt32 (value int32, flags apacks.Flags) { packInt(p,int64(value),flags) } func (p *JSONPacker) PackInt32 (value int32, flags apacks.Flags) { packInt(p.state,int64(value),flags) }
func (p *JSONPacker) PackInt64 (value int64, flags apacks.Flags) { packInt(p,value,flags)} func (p *JSONPacker) PackInt64 (value int64, flags apacks.Flags) { packInt(p.state,value,flags)}
func (p *JSONPacker) PackUInt8 (value uint8 , flags apacks.Flags) { packUInt(p,uint64(value),flags) } func (p *JSONPacker) PackUInt8 (value uint8 , flags apacks.Flags) { packUInt(p.state,uint64(value),flags) }
func (p *JSONPacker) PackUInt16 (value uint16, flags apacks.Flags) { packUInt(p,uint64(value),flags) } func (p *JSONPacker) PackUInt16 (value uint16, flags apacks.Flags) { packUInt(p.state,uint64(value),flags) }
func (p *JSONPacker) PackUInt32 (value uint32, flags apacks.Flags) { packUInt(p,uint64(value),flags) } func (p *JSONPacker) PackUInt32 (value uint32, flags apacks.Flags) { packUInt(p.state,uint64(value),flags) }
func (p *JSONPacker) PackUInt64 (value uint64, flags apacks.Flags) { packUInt(p, value,flags) } func (p *JSONPacker) PackUInt64 (value uint64, flags apacks.Flags) { packUInt(p.state, value,flags) }
func (p *JSONPacker) PackFloat32 (value float32, flags apacks.Flags) { packFloatString(p, float64(value), flags, 32) } func (p *JSONPacker) PackFloat32 (value float32, flags apacks.Flags) { packFloatString(p.state, float64(value), flags, 32) }
func (p *JSONPacker) PackFloat64 (value float64, flags apacks.Flags) { packFloatString(p, value, flags, 64) } func (p *JSONPacker) PackFloat64 (value float64, flags apacks.Flags) { packFloatString(p.state, value, flags, 64) }
func (p *JSONPacker) PackDate (value time.Time, flags apacks.Flags) { packDate(p,value,flags) } func (p *JSONPacker) PackDate (value time.Time, flags apacks.Flags) { packDate(p.state,value,flags) }
func (p *JSONPacker) PackList (builder func(apacks.ListPackBuilder, apacks.Flags), flags apacks.Flags) { func (p *JSONPacker) PackList (builder func(apacks.ListPackBuilder, apacks.Flags), flags apacks.Flags) {
@ -235,49 +229,49 @@ func (p *JSONPacker) packCompound (opener, closer byte, isnil bool, buildFn func
func packRaw (p *JSONPacker, value []byte, flags apacks.Flags) { func packRaw (state *apacks.State, value []byte, flags apacks.Flags) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
if value == nil { if value == nil {
p.state.W(cjson.G.NullValue) state.W(cjson.G.NullValue)
return return
} }
if len(value) == 0 { if len(value) == 0 {
p.state.Write2Byte('"','"') state.Write2Byte('"','"')
return return
} }
p.state.WOQ(flags.Quote(),'"',value) state.WOQ(flags.Quote(),'"',value)
} }
func packString (p *JSONPacker, value string , flags apacks.Flags) { func packString (state *apacks.State, value string , flags apacks.Flags) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
if len(value) == 0 { if len(value) == 0 {
p.state.Write2Byte('"','"') state.Write2Byte('"','"')
return return
} }
if flags.Encrypted() { if flags.Encrypted() {
packEncrypted(p, []byte(value), flags|apacks.FlagBinary64) packEncrypted(state, []byte(value), flags|apacks.FlagBinary64)
return return
} }
if flags.Binary() { if flags.Binary() {
packBinary(p,[]byte(value),flags) packBinary(state,[]byte(value),flags)
return return
} }
cjson.WriteString(p.state.ABuffer,value,flags.EscapeHTML()) cjson.WriteString(state.ABuffer,value,flags.EscapeHTML())
} }
func packEncrypted (p *JSONPacker, value []byte, flags apacks.Flags) { func packEncrypted (state *apacks.State, value []byte, flags apacks.Flags) {
r := p.state.Encrypter.Encrypt(value) r := state.Encrypter.Encrypt(value)
if !r.Ok() { if !r.Ok() {
p.state.SetError(r.Fail()) state.SetError(r.Fail())
return return
} }
@ -285,67 +279,67 @@ func packEncrypted (p *JSONPacker, value []byte, flags apacks.Flags) {
flags|= apacks.FlagBinary64 flags|= apacks.FlagBinary64
} }
packBinary(p,value,flags) packBinary(state,value,flags)
} }
func packBinary (p *JSONPacker, value []byte , flags apacks.Flags) { func packBinary (state *apacks.State, value []byte , flags apacks.Flags) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
if flags.Bin64() { if flags.Bin64() {
p.state.SetError(cjson.WriteBase64(p.state.ABuffer,value)) state.SetError(cjson.WriteBase64(state.ABuffer,value))
return return
} }
if flags.Bin32() { if flags.Bin32() {
p.state.SetError(cjson.WriteBase32(p.state.ABuffer,value)) state.SetError(cjson.WriteBase32(state.ABuffer,value))
return return
} }
p.state.SetError(apacks.G.ErrUnsupportedType) state.SetError(apacks.G.ErrUnsupportedType)
} }
func packBool (p *JSONPacker, value bool , flags apacks.Flags) { func packBool (state *apacks.State, value bool , flags apacks.Flags) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
cjson.WriteBool(p.state.ABuffer,value,flags.Quote()) cjson.WriteBool(state.ABuffer,value,flags.Quote())
} }
func packInt (p *JSONPacker, value int64 , flags apacks.Flags) { func packInt (state *apacks.State, value int64 , flags apacks.Flags) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
cjson.WriteInt(p.state.ABuffer,value,flags.Quote()) cjson.WriteInt(state.ABuffer,value,flags.Quote())
} }
func packUInt (p *JSONPacker, value uint64 , flags apacks.Flags) { func packUInt (state *apacks.State, value uint64 , flags apacks.Flags) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
cjson.WriteUint(p.state.ABuffer,value,flags.Quote()) cjson.WriteUint(state.ABuffer,value,flags.Quote())
} }
func packFloat (p *JSONPacker, value float64, flags apacks.Flags) { func packFloat (state *apacks.State, value float64, flags apacks.Flags) {
packFloatString(p, value, flags, 64) } packFloatString(state, value, flags, 64) }
func packFloatString (p *JSONPacker, f float64, flags apacks.Flags, bits int) { func packFloatString (state *apacks.State, f float64, flags apacks.Flags, bits int) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
cjson.WriteFloat(p.state.ABuffer,f,bits,flags.Quote()) cjson.WriteFloat(state.ABuffer,f,bits,flags.Quote())
} }
func packDate(p *JSONPacker, value time.Time, flags apacks.Flags) { func packDate(state *apacks.State, value time.Time, flags apacks.Flags) {
if p.state.Error != nil { if state.Error != nil {
panic(apacks.G.ErrInvalidState.WrapWithCause(p.state.Error)) panic(apacks.G.ErrInvalidState.WrapWithCause(state.Error))
} }
cjson.WriteDate(p.state.ABuffer,value,flags.DateFormat(),true) cjson.WriteDate(state.ABuffer,value,flags.DateFormat(),true)
} }
@ -353,120 +347,120 @@ func packDate(p *JSONPacker, value time.Time, flags apacks.Flags) {
func packListString (p *JSONPacker, list []string, flags apacks.Flags) { func packListString (state *apacks.State, list []string, flags apacks.Flags) {
if !checkList(p,list == nil, len(list) ==0) { if !checkList(state,list == nil, len(list) ==0) {
return return
} }
p.state.WriteByte('[') state.WriteByte('[')
for i,v := range list { for i,v := range list {
if i > 0 { if i > 0 {
p.state.WriteByte(',') state.WriteByte(',')
} }
packString(p,v,flags) packString(state,v,flags)
if p.state.Error != nil { if state.Error != nil {
return return
} }
} }
p.state.WriteByte(']') state.WriteByte(']')
} }
func packListBool (p *JSONPacker, list []bool, flags apacks.Flags) { func packListBool (state *apacks.State, list []bool, flags apacks.Flags) {
if !checkList(p,list == nil, len(list) ==0) { if !checkList(state,list == nil, len(list) ==0) {
return return
} }
p.state.WriteByte('[') state.WriteByte('[')
for i,v := range list { for i,v := range list {
if i > 0 { if i > 0 {
p.state.WriteByte(',') state.WriteByte(',')
} }
packBool(p,v,flags) packBool(state,v,flags)
if p.state.Error != nil { if state.Error != nil {
return return
} }
} }
p.state.WriteByte(']') state.WriteByte(']')
} }
func packListInt [T int | int8 | int16 | int32 | int64](p *JSONPacker, list []T, flags apacks.Flags) { func packListInt [T int | int8 | int16 | int32 | int64](state *apacks.State, list []T, flags apacks.Flags) {
if !checkList(p,list == nil, len(list) ==0) { if !checkList(state,list == nil, len(list) ==0) {
return return
} }
p.state.WriteByte('[') state.WriteByte('[')
for i,v := range list { for i,v := range list {
if i > 0 { if i > 0 {
p.state.WriteByte(',') state.WriteByte(',')
} }
packInt(p,int64(v),flags) packInt(state,int64(v),flags)
if p.state.Error != nil { if state.Error != nil {
return return
} }
} }
p.state.WriteByte(']') state.WriteByte(']')
} }
func packListUInt [T uint | uint8 | uint16 | uint32 | uint64](p *JSONPacker, list []T, flags apacks.Flags) { func packListUInt [T uint | uint8 | uint16 | uint32 | uint64](state *apacks.State, list []T, flags apacks.Flags) {
if !checkList(p,list == nil, len(list) ==0) { if !checkList(state,list == nil, len(list) ==0) {
return return
} }
p.state.WriteByte('[') state.WriteByte('[')
for i,v := range list { for i,v := range list {
if i > 0 { if i > 0 {
p.state.WriteByte(',') state.WriteByte(',')
} }
packUInt(p,uint64(v),flags) packUInt(state,uint64(v),flags)
if p.state.Error != nil { if state.Error != nil {
return return
} }
} }
p.state.WriteByte(']') state.WriteByte(']')
} }
func packListFloat[T float32 | float64](p *JSONPacker, list []T, flags apacks.Flags, bits int) { func packListFloat[T float32 | float64](state *apacks.State, list []T, flags apacks.Flags, bits int) {
if !checkList(p,list == nil, len(list) ==0) { if !checkList(state,list == nil, len(list) ==0) {
return return
} }
p.state.WriteByte('[') state.WriteByte('[')
for i,v := range list { for i,v := range list {
if i > 0 { if i > 0 {
p.state.WriteByte(',') state.WriteByte(',')
} }
packFloatString(p,float64(v),flags,bits) packFloatString(state,float64(v),flags,bits)
if p.state.Error != nil { if state.Error != nil {
return return
} }
} }
p.state.WriteByte(']') state.WriteByte(']')
} }
func packListDate (p *JSONPacker, list []time.Time, flags apacks.Flags) { func packListDate (state *apacks.State, list []time.Time, flags apacks.Flags) {
if !checkList(p,list == nil, len(list) ==0) { if !checkList(state,list == nil, len(list) ==0) {
return return
} }
p.state.WriteByte('[') state.WriteByte('[')
for i,v := range list { for i,v := range list {
if i > 0 { if i > 0 {
p.state.WriteByte(',') state.WriteByte(',')
} }
packDate(p,v,flags) packDate(state,v,flags)
if p.state.Error != nil { if state.Error != nil {
return return
} }
} }
p.state.WriteByte(']') state.WriteByte(']')
} }
func checkList (p *JSONPacker, isNull, isEmpty bool) bool { func checkList (state *apacks.State, isNull, isEmpty bool) bool {
if isNull { if isNull {
p.state.Write2Byte('"','"') state.Write2Byte('"','"')
return false return false
} }
if isEmpty { if isEmpty {
p.state.Write2Byte('[',']') state.Write2Byte('[',']')
return false return false
} }
return true return true

30
apacks/pkjson/list_pack_builder.go
Unescape View File

@ -40,22 +40,20 @@ func (p *JSONPacker) ItemString (value string, flags apacks.Flags) { p.addItem(f
func (p *JSONPacker) ItemBool (value bool, flags apacks.Flags) { p.addItem(func (){ p.PackBool(value,flags) }) } func (p *JSONPacker) ItemBool (value bool, flags apacks.Flags) { p.addItem(func (){ p.PackBool(value,flags) }) }
func (p *JSONPacker) ItemInt (value int , flags apacks.Flags) { p.addItem(func (){ packInt(p,int64(value),flags) }) } func (p *JSONPacker) ItemInt8 (value int8 , flags apacks.Flags) { p.addItem(func (){ packInt(p.state,int64(value),flags) }) }
func (p *JSONPacker) ItemInt8 (value int8 , flags apacks.Flags) { p.addItem(func (){ packInt(p,int64(value),flags) }) } func (p *JSONPacker) ItemInt16 (value int16, flags apacks.Flags) { p.addItem(func (){ packInt(p.state,int64(value),flags) }) }
func (p *JSONPacker) ItemInt16 (value int16, flags apacks.Flags) { p.addItem(func (){ packInt(p,int64(value),flags) }) } func (p *JSONPacker) ItemInt32 (value int32, flags apacks.Flags) { p.addItem(func (){ packInt(p.state,int64(value),flags) }) }
func (p *JSONPacker) ItemInt32 (value int32, flags apacks.Flags) { p.addItem(func (){ packInt(p,int64(value),flags) }) } func (p *JSONPacker) ItemInt64 (value int64, flags apacks.Flags) { p.addItem(func (){ packInt(p.state,value,flags) }) }
func (p *JSONPacker) ItemInt64 (value int64, flags apacks.Flags) { p.addItem(func (){ packInt(p,value,flags) }) }
func (p *JSONPacker) ItemUInt8 (value uint8 , flags apacks.Flags){ p.addItem(func (){ packUInt(p.state,uint64(value),flags) }) }
func (p *JSONPacker) ItemUInt (value uint , flags apacks.Flags){ p.addItem(func (){ packUInt(p,uint64(value),flags) }) } func (p *JSONPacker) ItemUInt16 (value uint16, flags apacks.Flags){ p.addItem(func (){ packUInt(p.state,uint64(value),flags) }) }
func (p *JSONPacker) ItemUInt8 (value uint8 , flags apacks.Flags){ p.addItem(func (){ packUInt(p,uint64(value),flags) }) } func (p *JSONPacker) ItemUInt32 (value uint32, flags apacks.Flags){ p.addItem(func (){ packUInt(p.state,uint64(value),flags) }) }
func (p *JSONPacker) ItemUInt16 (value uint16, flags apacks.Flags){ p.addItem(func (){ packUInt(p,uint64(value),flags) }) } func (p *JSONPacker) ItemUInt64 (value uint64, flags apacks.Flags){ p.addItem(func (){ packUInt(p.state,uint64(value),flags) }) }
func (p *JSONPacker) ItemUInt32 (value uint32, flags apacks.Flags){ p.addItem(func (){ packUInt(p,uint64(value),flags) }) }
func (p *JSONPacker) ItemUInt64 (value uint64, flags apacks.Flags){ p.addItem(func (){ packUInt(p,uint64(value),flags) }) } func (p *JSONPacker) ItemFloat32 (value float32, flags apacks.Flags){ p.addItem(func (){ packFloatString(p.state,float64(value),flags,32)})}
func (p *JSONPacker) ItemFloat64 (value float64, flags apacks.Flags){ p.addItem(func (){ packFloatString(p.state,value,flags,64) })}
func (p *JSONPacker) ItemFloat32 (value float32, flags apacks.Flags){ p.addItem(func (){ packFloatString(p,float64(value),flags,32)})}
func (p *JSONPacker) ItemFloat64 (value float64, flags apacks.Flags){ p.addItem(func (){ packFloatString(p,value,flags,64) })} func (p *JSONPacker) ItemDate (value time.Time, flags apacks.Flags) { p.addItem(func(){ packDate(p.state,value,flags); p.state.Inc() })}
func (p *JSONPacker) ItemDate (value time.Time, flags apacks.Flags) { p.addItem(func(){ packDate(p,value,flags); p.state.Inc() })}
func (p *JSONPacker) ItemList (builder func(apacks.ListPackBuilder, apacks.Flags), flags apacks.Flags) { func (p *JSONPacker) ItemList (builder func(apacks.ListPackBuilder, apacks.Flags), flags apacks.Flags) {

2
apacks/pkjson/object_pack_builder.go
Unescape View File

@ -102,7 +102,7 @@ func (p *JSONPacker) addField(name string, caller func()) {
if p.state.Count() > 0 { if p.state.Count() > 0 {
p.state.WriteByte(',') p.state.WriteByte(',')
} }
packString(p,name, apacks.FlagScapeHTML) packString(p.state,name, apacks.FlagScapeHTML)
if p.state.Error != nil { if p.state.Error != nil {
return return
} }

30
apacks/pkjson/rpacker.go
Unescape View File

@ -25,7 +25,6 @@ package pkjson
import ( import (
"apacks" "apacks"
"fmt"
"reflect" "reflect"
"sync" "sync"
) )
@ -34,9 +33,7 @@ type (
//rPackerFnc func (state *apacks.State, rvalue reflect.Value, flags apacks.Flags) rPackerFnc func (state *apacks.State, rvalue reflect.Value, flags apacks.Flags)
rPackerFnc func (packer *JSONPacker, rvalue reflect.Value, flags apacks.Flags)
) )
@ -52,7 +49,7 @@ func rTypePacker (rtype reflect.Type) rPackerFnc {
wg.Add(1) wg.Add(1)
fi,ld := g.packersCache.LoadOrStore(rtype, rPackerFnc(func (e *JSONPacker, v reflect.Value, f apacks.Flags) { fi,ld := g.packersCache.LoadOrStore(rtype, rPackerFnc(func (e *apacks.State, v reflect.Value, f apacks.Flags) {
wg.Wait() wg.Wait()
fn(e,v,f) fn(e,v,f)
})) }))
@ -69,29 +66,22 @@ func rTypePacker (rtype reflect.Type) rPackerFnc {
func _rTypePacker(rtype reflect.Type) rPackerFnc { func _rTypePacker(rtype reflect.Type) rPackerFnc {
fmt.Printf(" %s Implementa %s ) %v\n",rtype.String(),g.packBuilderType.String(),rtype.Implements(g.packBuilderType))
if rtype.Implements(g.packBuilderType) {
fmt.Println("LLeve hasta la reflection")
return func (p *JSONPacker, v reflect.Value, f apacks.Flags) {
p.state.SetError(v.Interface().(apacks.PackBuilder).BuildPack(p))
}
}
switch rtype.Kind() { switch rtype.Kind() {
case reflect.Bool : return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packBool (p,v.Bool (),f )} case reflect.Bool : return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packBool (s,v.Bool (),f )}
case reflect.String : return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packString(p,v.String(),f )} case reflect.String : return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packString(s,v.String(),f )}
case reflect.Int, case reflect.Int,
reflect.Int8, reflect.Int8,
reflect.Int16, reflect.Int16,
reflect.Int32, reflect.Int32,
reflect.Int64 : return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packInt (p,v.Int (),f )} reflect.Int64 : return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packInt (s,v.Int (),f )}
case reflect.Uint, case reflect.Uint,
reflect.Uint8, reflect.Uint8,
reflect.Uint16, reflect.Uint16,
reflect.Uint32, reflect.Uint32,
reflect.Uint64 : return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packUInt (p,v.Uint (),f )} reflect.Uint64 : return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packUInt (s,v.Uint (),f )}
case reflect.Float32: return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packFloatString(p,v.Float(),f,32) } case reflect.Float32: return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packFloatString(s,v.Float(),f,32) }
case reflect.Float64: return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packFloatString(p,v.Float(),f,64) } case reflect.Float64: return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packFloatString(s,v.Float(),f,64) }
case reflect.Pointer: case reflect.Pointer:
return rPointerPacker(rtype) return rPointerPacker(rtype)
@ -116,8 +106,8 @@ func _rTypePacker(rtype reflect.Type) rPackerFnc {
} }
func unsupportedTypePacker(p *JSONPacker, _ reflect.Value, _ apacks.Flags) { func unsupportedTypePacker(state *apacks.State, _ reflect.Value, _ apacks.Flags) {
p.state.SetError(apacks.G.ErrUnsupportedType) state.SetError(apacks.G.ErrUnsupportedType)
} }

6
apacks/pkjson/rpacker_interface.go
Unescape View File

@ -29,10 +29,10 @@ import (
"reflect" "reflect"
) )
func rInterfacePacker (p *JSONPacker, v reflect.Value, f apacks.Flags) { func rInterfacePacker (s *apacks.State, v reflect.Value, f apacks.Flags) {
if v.IsNil() { if v.IsNil() {
p.state.W(cjson.G.NullValue) s.W(cjson.G.NullValue)
return return
} }
rValuePacker(v.Elem())(p,v,f) rValuePacker(v.Elem())(s,v,f)
} }

28
apacks/pkjson/rpacker_list.go
Unescape View File

@ -58,7 +58,7 @@ func newRList(rtype reflect.Type) *rList {
func (p rList) packBinary (s *JSONPacker, v reflect.Value, f apacks.Flags) { func (p rList) packBinary (s *apacks.State, v reflect.Value, f apacks.Flags) {
if f.Binary() { if f.Binary() {
packBinary(s, v.Interface().([]byte), f) packBinary(s, v.Interface().([]byte), f)
return return
@ -67,7 +67,7 @@ func (p rList) packBinary (s *JSONPacker, v reflect.Value, f apacks.Flags) {
} }
func (p rList) packBinarySlice (s *JSONPacker, v reflect.Value, f apacks.Flags) { func (p rList) packBinarySlice (s *apacks.State, v reflect.Value, f apacks.Flags) {
if f.Binary() { if f.Binary() {
packBinary(s, v.Interface().([]byte), f) packBinary(s, v.Interface().([]byte), f)
return return
@ -78,13 +78,13 @@ func (p rList) packBinarySlice (s *JSONPacker, v reflect.Value, f apacks.Flags)
func (p rList) packSlice(s *JSONPacker, v reflect.Value, f apacks.Flags) { func (p rList) packSlice(s *apacks.State, v reflect.Value, f apacks.Flags) {
if v.IsNil() { if v.IsNil() {
s.state.W(cjson.G.NullValue) s.W(cjson.G.NullValue)
return return
} }
if s.state.Level > maxCyclesAfter { if s.Level > maxCyclesAfter {
cp := struct { cp := struct {
p interface{} p interface{}
l int l int
@ -92,10 +92,10 @@ func (p rList) packSlice(s *JSONPacker, v reflect.Value, f apacks.Flags) {
p: v.UnsafePointer(), p: v.UnsafePointer(),
l: v.Len(), l: v.Len(),
} }
if fn,ok := s.state.CheckCycle(cp); ok { if fn,ok := s.CheckCycle(cp); ok {
defer fn() defer fn()
} else { } else {
s.state.SetError(apacks.G.ErrRedundantPack) s.SetError(apacks.G.ErrRedundantPack)
return return
} }
} }
@ -105,28 +105,28 @@ func (p rList) packSlice(s *JSONPacker, v reflect.Value, f apacks.Flags) {
func (p rList) pack (s *JSONPacker, v reflect.Value, f apacks.Flags) { func (p rList) pack (s *apacks.State, v reflect.Value, f apacks.Flags) {
if v.IsNil() { if v.IsNil() {
s.state.W(cjson.G.NullValue) s.W(cjson.G.NullValue)
return return
} }
if v.Len() == 0 { if v.Len() == 0 {
s.state.Write2Byte('[',']') s.Write2Byte('[',']')
return return
} }
s.state.Open('[') s.Open('[')
for i:=0; i<v.Len(); i++ { for i:=0; i<v.Len(); i++ {
if i > 0 { if i > 0 {
s.state.WriteByte(',') s.WriteByte(',')
} }
p.packFn(s,v.Index(i),f) p.packFn(s,v.Index(i),f)
if s.state.Error != nil { if s.Error != nil {
return return
} }
} }
s.state.Close(']') s.Close(']')
} }

24
apacks/pkjson/rpacker_map.go
Unescape View File

@ -53,26 +53,26 @@ func newRMap(rtype reflect.Type) *rMap {
} }
func (p *rMap) pack (s *JSONPacker, v reflect.Value, f apacks.Flags) { func (p *rMap) pack (s *apacks.State, v reflect.Value, f apacks.Flags) {
if p.keyFn == nil { if p.keyFn == nil {
s.state.SetError(apacks.G.ErrInvalidKey) s.SetError(apacks.G.ErrInvalidKey)
return return
} }
if v.IsNil() { if v.IsNil() {
s.state.W(cjson.G.NullValue) s.W(cjson.G.NullValue)
return return
} }
if v.Len() == 0 { if v.Len() == 0 {
s.state.Write2Byte('{','}') s.Write2Byte('{','}')
return return
} }
if s.state.Level > maxCyclesAfter { if s.Level > maxCyclesAfter {
if fn,ok := s.state.CheckCycle(v.UnsafePointer()); ok { if fn,ok := s.CheckCycle(v.UnsafePointer()); ok {
defer fn() defer fn()
} else { } else {
s.state.SetError(apacks.G.ErrRedundantPack) s.SetError(apacks.G.ErrRedundantPack)
return return
} }
} }
@ -85,28 +85,28 @@ func (p *rMap) pack (s *JSONPacker, v reflect.Value, f apacks.Flags) {
v: mi.Value(), v: mi.Value(),
} }
if er := p.keyFn(&ls[i], mi.Key()); er != nil { if er := p.keyFn(&ls[i], mi.Key()); er != nil {
s.state.SetError(er) s.SetError(er)
return return
} }
} }
sort.Sort(ls) sort.Sort(ls)
s.state.Open ('{') s.Open ('{')
for i:=0; i<len(ls); i++ { for i:=0; i<len(ls); i++ {
if i>0 { if i>0 {
s.state.WriteByte(',') s.WriteByte(',')
} }
packString(s,ls[i].k,ls[i].f) packString(s,ls[i].k,ls[i].f)
if s.Error != nil { if s.Error != nil {
return return
} }
s.state.WriteByte(':') s.WriteByte(':')
p.packFn(s,ls[i].v,0) p.packFn(s,ls[i].v,0)
if s.Error != nil { if s.Error != nil {
return return
} }
} }
s.state.Close('}') s.Close('}')
} }

14
apacks/pkjson/rpacker_object.go
Unescape View File

@ -46,7 +46,7 @@ func rObjectPacker (rtype reflect.Type) rPackerFnc {
if !ok { if !ok {
op,_ = g.fieldsCache.LoadOrStore(rtype,*newRObject(rtype)) op,_ = g.fieldsCache.LoadOrStore(rtype,*newRObject(rtype))
} }
return func(s *JSONPacker, value reflect.Value, flags apacks.Flags) { return func(s *apacks.State, value reflect.Value, flags apacks.Flags) {
op.(rObject).pack(s,value,flags) op.(rObject).pack(s,value,flags)
} }
//return (op.(rObject)).pack //return (op.(rObject)).pack
@ -213,7 +213,7 @@ func newRObject(rtype reflect.Type) *rObject {
func (o rObject) pack (s *JSONPacker, v reflect.Value, f apacks.Flags) { func (o rObject) pack (s *apacks.State, v reflect.Value, f apacks.Flags) {
nx := byte('{') nx := byte('{')
FieldLoop: FieldLoop:
for i:= range o.fields { for i:= range o.fields {
@ -232,19 +232,19 @@ FieldLoop:
if fd.flags.OmitEmpty() && isEmptyValue(v) { if fd.flags.OmitEmpty() && isEmptyValue(v) {
continue continue
} }
s.state.WriteByte(nx) s.WriteByte(nx)
nx = ',' nx = ','
if fd.flags.EscapeHTML() { if fd.flags.EscapeHTML() {
s.state.WriteString(fd.nameS) s.WriteString(fd.nameS)
} else { } else {
s.state.WriteString(fd.nameU) s.WriteString(fd.nameU)
} }
fd.packerFn(s,fv, fd.flags|f) fd.packerFn(s,fv, fd.flags|f)
} }
if nx == '{' { if nx == '{' {
s.state.Write2Byte('{','}') s.Write2Byte('{','}')
} else { } else {
s.state.WriteByte('}') s.WriteByte('}')
} }
} }

12
apacks/pkjson/rpacker_pointer.go
Unescape View File

@ -47,19 +47,19 @@ func newRPointer (rtype reflect.Type) *rPointer {
} }
func (p rPointer) pack (s *JSONPacker, v reflect.Value, f apacks.Flags) { func (p rPointer) pack (s *apacks.State, v reflect.Value, f apacks.Flags) {
if v.IsNil() { if v.IsNil() {
s.state.W(cjson.G.NullValue) s.W(cjson.G.NullValue)
return return
} }
s.state.Level++ s.Level++
if s.state.Level > maxCyclesAfter { if s.Level > maxCyclesAfter {
if fn,ok := s.state.CheckCycle(v.Interface()); ok { if fn,ok := s.CheckCycle(v.Interface()); ok {
defer fn() defer fn()
} else { } else {
return return
} }
} }
p.elemPackFn(s,v.Elem(),f) p.elemPackFn(s,v.Elem(),f)
s.state.Level-- s.Level--
} }

4
apacks/pkjson/rpacker_value.go
Unescape View File

@ -36,6 +36,6 @@ func rValuePacker (rvalue reflect.Value) rPackerFnc {
} }
func invalidValuePacker(p *JSONPacker, _ reflect.Value, _ apacks.Flags) { func invalidValuePacker(state *apacks.State, _ reflect.Value, _ apacks.Flags) {
p.state.SetError(apacks.G.ErrInvalidValue) state.SetError(apacks.G.ErrInvalidValue)
} }

65
app/main.go
Unescape View File

@ -2,7 +2,6 @@ package main
import ( import (
"alogs" "alogs"
"apacks/pkjson"
"errs" "errs"
"fmt" "fmt"
"mems" "mems"
@ -55,27 +54,67 @@ func Append2 (_ *alogs.Entry) error {
func main() { func main() {
entry := alogs.NewEntry(nil,alogs.LevelFatal|alogs.LevelDebug,"Un mensage",nil, var fs flds.SFields
alogs.EntryWithFields(
flds.NewAFieldString("UnCampo","valor"), fs = fs.AddField(flds.NewSFieldSigned("Z",1))
flds.NewAFieldSigned("UnNumero",3), fs = fs.AddField(flds.NewSFieldSigned("a",1))
flds.NewAFieldSigned("UnNumero",1)), fs = fs.AddField(flds.NewSFieldSigned("m",1))
alogs.EntryWithField("Una cabncion",true), fs = fs.AddField(flds.NewSFieldSigned("b",1))
)
fs.Sort()
for i:= 0; i<len(fs); i++ {
fmt.Printf("%s\n",fs[i].Name())
}
/*
cx,cl := context.WithCancel(context.Background())
//cl()
l,er := alogs.NewActiveLogger(alogs.LevelAll,
alogs.ActiveLoggerWithContext(cx,true),
alogs.ActiveLoggerWithOnError(func(a *alogs.ActiveLogger,err error, s alogs.Logger){
if s != nil {
//fmt.Printf("Error producido en logger [%s] se procede a su paro\n", s.Name())
//fmt.Println(errs.Encode(err,nil))
fmt.Print(errs.Encode(s.Stop(),nil))
}
}),
)
res := pkjson.Pack(entry) if er != nil {
if !res.Ok() { fmt.Print(errs.Encode(er,nil))
fmt.Print(errs.Encode(res.Fail(),nil)) time.Sleep(500*time.Millisecond)
return return
} }
fmt.Println(string(res.Value()))
l1,_:= alogs.NewLoggerCore("MiLogger",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append)))
l2,_:=alogs.NewLoggerCore("LoggerProblematico",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append2)))
l.AddLogger(l1)
l.AddLogger(l2)
if er := l.Start(); er != nil {
e := errs.Encode(er,nil)
fmt.Printf("\n %s\n%s\n",e,er.Error())
return
} }
for i:=0; i<3; i++ {
l.Warn("Esto es un mensage")
}
//time.Sleep(1000 * time.Millisecond)
cl()
*/
}

82
core/errs/err_fields.go
Unescape View File

@ -1,82 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name err_fields.go
// Created by DEV
// Modified 30/04/2024
//
// Copyright 2024 activething.com
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package errs
import (
"errs/erdata"
"vals/flds"
)
type (
ErrFields struct {
error
flds.AFields
}
)
func (e ErrFields) Unwrap() error {
return e.error }
func (e ErrFields) UnwrapAll() []error {
return nil }
func (e ErrFields) WrapWithInfo (options ...ErrInfoFnc) error {
return WrapWithInfo(e,options...) }
func (e ErrFields) WrapWithCause(cause error) error {
return WrapWithCause(e,cause) }
func (e ErrFields) WrapWithTrace(offset int) error {
return WrapWithTrace(e,offset) }
func (e ErrFields) WrapWithFieldString (name, value string) error {
return WrapWithFieldString(e,name,value) }
func (e ErrFields) WrapWithMessage (msg string) error {
return WrapWithMessage(e,msg) }
func (e ErrFields) String () string {
return string(G.Encoder.EncodeError(e)) }
func (e ErrFields) Collect (collector erdata.Collector) {
}

136
core/vals/flds/_deprecated/afield.go
Unescape View File

@ -0,0 +1,136 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name afield.go
// Created by DEV
// Modified 30/04/2024
//
// Copyright 2024 activething.com
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package _deprecated
import (
"time"
"vals/flds"
)
type (
AField struct {
fs *AFields
hp int
}
)
func (f AField) IsValid() bool {
return f.fs.heads[f.hp].pos != -1 }
func (f AField) Name () string {
return f.fs.heads[f.hp].name
}
func (f AField) Kind () flds.Kind {
return f.fs.heads[f.hp].kind
}
func (f AField) Value() any {
if f.fs.heads[f.hp].pos == -1 {
return nil
}
p := f.fs.heads[f.hp].pos
switch f.fs.heads[f.hp].kind {
case flds.KindAny: return f.fs.anys[p]
case flds.KindError: return f.fs.anys[p].(error)
case flds.KindBool: return f.fs.nums[p] != 0
case flds.KindSigned: return f.fs.nums[p]
case flds.KindUnsigned: return uint(f.fs.nums[p])
case flds.KindFloat: return f.fs.floats [p]
case flds.KindString: return f.fs.strings [p]
case flds.KindDate: return f.fs.dates [p]
case flds.KindBinary: return f.fs.binaries[p]
default:
// Handle unknown field type
return nil
}
}
func (f AField) Any () (any,bool) {
return f.Value(), f.hp != -1 }
func (f AField) Bool () (bool,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindBool {
return false,false
}
return f.fs.nums[f.fs.heads[f.hp].pos] > 0,true
}
func (f AField) String () (string,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindString {
return "",false
}
return f.fs.strings[f.fs.heads[f.hp].pos],true
}
func (f AField) Signed () (int,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindSigned {
return 0,false
}
return f.fs.nums[f.fs.heads[f.hp].pos],true
}
func (f AField) Unsigned () (uint,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindUnsigned {
return 0,false
}
return uint(f.fs.nums[f.fs.heads[f.hp].pos]),true
}
func (f AField) Date () (time.Time,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindDate {
var z time.Time
return z,false
}
return f.fs.dates[f.fs.heads[f.hp].pos],true
}
func (f AField) Time () (time.Time,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindTime {
var z time.Time
return z,false
}
return f.fs.dates[f.fs.heads[f.hp].pos],true
}
func (f AField) Error () (error,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindError {
return nil,false
}
return f.fs.anys[f.fs.heads[f.hp].pos].(error),true
}
func (f AField) Binary () ([]byte,bool) {
if f.hp != -1 || f.fs.heads[f.hp].kind != flds.KindBinary {
return nil,false
}
return f.fs.binaries[f.fs.heads[f.hp].pos],true
}

215
core/vals/flds/_deprecated/afields.go
Unescape View File

@ -0,0 +1,215 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name afields.go
// Created by DEV
// Modified 30/04/2024
//
// Copyright 2024 activething.com
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package _deprecated
import (
"fmt"
"sort"
"time"
"vals/flds"
)
type (
AFields struct {
heads []head
kinds flds.Kind
anys []any
nums []int
floats []float64
strings []string
dates []time.Time
binaries [][]byte
}
AFieldsFnc func(afields *AFields)
AFieldsMapFnc func(field AField) bool
)
func AcquireAFields (options ...AFieldsFnc) *AFields {
return flds.g.pool.Get().init(options) }
func ReleaseAFields (fields *AFields) {
if fields == nil {
return
}
flds.g.pool.Put(fields.Reset())
}
func newAFields () *AFields {
return &AFields{} }
func NewAFields (options ...AFieldsFnc) *AFields {
return newAFields().init(options) }
func (f *AFields) Len () int {
return len(f.heads) }
func (f *AFields) Has (name string) bool {
return f.has(name) != -1 }
func (f *AFields) init (options []AFieldsFnc) *AFields {
for _,o := range options {
o(f)
}
return f
}
func (f *AFields) Reset() *AFields {
f.heads = f.heads[:0]
f.kinds = 0
f.anys = f.anys [:0]
f.nums = f.nums [:0]
f.floats = f.floats [:0]
f.strings = f.strings [:0]
f.dates = f.dates [:0]
f.binaries= f.binaries[:0]
return f
}
func (f *AFields) Kinds() flds.Kind {
return f.kinds }
func (f *AFields) GetField (name string) AField {
return AField{
fs: f,
hp: f.has(name),
}
}
func (f *AFields) Map (mapFn AFieldsMapFnc) {
fl := AField{ fs : f }
for i := 0; i<len(f.heads); i++ {
fl.hp = i
if !mapFn(fl) {
return
}
}
}
func (f *AFields) Sort () {
sort.Slice(f.heads, func(i, j int) bool {
return f.heads[i].name < f.heads[j].name
})
}
func (f *AFields) AddAny (name string, value any) {
switch t := value.(type) {
case string : f.AddString(name,t)
case bool : f.AddBool (name,t)
case int : f.AddSigned(name,t)
case int8 : f.AddSigned(name,int(t))
case int16 : f.AddSigned(name,int(t))
case int32 : f.AddSigned(name,int(t))
case int64 : f.AddSigned(name,int(t))
case uint : f.AddUnsigned(name,t)
case uint8 : f.AddUnsigned(name,uint(t))
case uint16 : f.AddUnsigned(name,uint(t))
case uint32 : f.AddUnsigned(name,uint(t))
case uint64 : f.AddUnsigned(name,uint(t))
case float32 : f.AddFloat(name,float64(t))
case float64 : f.AddFloat(name,t)
case []byte : f.AddBinary(name,t)
case time.Time: f.AddDate(name,t)
default:
f.addField(name, flds.KindAny,len(f.anys)).anys = append(f.anys, value)
}
}
func (f *AFields) AddError(name string, value error) {
f.addField(name, flds.KindError,len(f.anys)).anys = append(f.anys,value) }
func (f *AFields) AddBool (name string, value bool) {
v := 0
if value {
v=1
}
f.addField(name, flds.KindBool,len(f.nums)).nums = append(f.nums,v)
}
func (f *AFields) AddSigned (name string, value int) {
f.addField(name, flds.KindSigned,len(f.nums)).nums = append(f.nums,value) }
func (f *AFields) AddUnsigned(name string, value uint) {
f.addField(name, flds.KindUnsigned,len(f.nums)).nums = append(f.nums,int(value)) }
func (f *AFields) AddFloat(name string, value float64) {
f.addField(name, flds.KindFloat,len(f.floats)).floats = append(f.floats,value) }
func (f *AFields) AddDate (name string, value time.Time) {
f.addField(name, flds.KindDate,len(f.dates)).dates = append(f.dates,value) }
func (f *AFields) AddTime (name string, value time.Time) {
f.addField(name, flds.KindTime,len(f.dates)).dates = append(f.dates,value) }
func (f *AFields) AddString(name string, value string) {
f.addField(name, flds.KindString,len(f.strings)).strings = append(f.strings,value) }
func (f *AFields) AddBinary(name string, value []byte) {
f.addField(name, flds.KindBinary,len(f.binaries)).binaries = append(f.binaries,value) }
func (f *AFields) addField (name string, kind flds.Kind, pos int) *AFields {
for i:=1; f.has(name) == -1; i++ {
name = fmt.Sprintf("fmtNameDuplicated",name,i)
}
f.kinds |= kind
f.heads = append(f.heads, head{
name: name,
kind: kind,
pos : pos,
})
return f
}
func (f *AFields) has (name string) int {
for i,h := range f.heads {
if h.name == name {
return i
}
}
return -1
}

28
core/vals/flds/pkflds/afields_list_packer.go → core/vals/flds/_deprecated/heads.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name afields_list_packer.go // File name heads.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -21,29 +21,17 @@
// limitations under the License. // limitations under the License.
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
package pkflds package _deprecated
import ( import "vals/flds"
"apacks"
"vals/flds"
)
type ( type (
AFieldsListPacker flds.AFields head struct {
) name string
kind flds.Kind
pos int
func (f AFieldsListPacker) BuildPack (packer apacks.ValuePacker) error {
packer.PackList(func (b apacks.ListPackBuilder, _ apacks.Flags) {
for _,fl := range f {
b.ItemObject(func (ob apacks.ObjectPackBuilder, _ apacks.Flags){
AFieldBuildPack(ob,fl)
},0)
} }
},0) )
return nil
}

33
core/vals/flds/active.go
Unescape View File

@ -23,8 +23,6 @@
package flds package flds
import "reflect"
const( const(
kindBits = 16 kindBits = 16
@ -66,28 +64,13 @@ var (
) )
func NewAField (name string, value any) AField {
switch t := value.(type) { /* deprecated
case bool : func checkFieldName (name string) bool {
return NewAFieldBool (name,t) if name == "" {
case []byte : return NewAFieldBinary(name,t) panic(G.ErrInvalidName)
case string : return NewAFieldString(name,t)
case int : return NewAFieldSigned(name,t)
case int8 : return NewAFieldSigned(name,int(t))
case int16 : return NewAFieldSigned(name,int(t))
case int32 : return NewAFieldSigned(name,int(t))
case int64 : return NewAFieldSigned(name,int(t))
case uint : return NewAFieldUnsigned(name,t)
case uint8 : return NewAFieldUnsigned(name,uint(t))
case uint16 : return NewAFieldUnsigned(name,uint(t))
case uint32 : return NewAFieldUnsigned(name,uint(t))
case uint64 : return NewAFieldUnsigned(name,uint(t))
case uintptr: return NewAFieldUnsigned(name,uint(t))
case float64: return NewAFieldFloat(name,t)
case float32: return NewAFieldFloat(name,float64(t))
case error : return NewAFieldError(name,t)
case reflect.Value : return NewAFieldReflect(name,t)
default:
return NewAFieldAny(name,value)
} }
return true
} }
*/

57
core/vals/flds/afield_binary.go
Unescape View File

@ -1,57 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name afield_binary.go
// Created by DEV
// Modified 01/05/2024
//
// Copyright 2024 activething.com
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package flds
type (
AFieldBinary struct {
partAField
value []byte
}
)
func NewAFieldBinary (name string, value []byte) *AFieldBinary {
return &AFieldBinary{
partAField: makePartAField(name),
value : value } }
func (_ AFieldBinary) Kind () Kind {
return KindBinary }
func (f AFieldBinary) Value() any {
return f.value }
func (f AFieldBinary) Any () (any,bool) {
return f.value,true }
func (f AFieldBinary) Binary() ([]byte,bool) {
return f.value,true }

31
core/vals/flds/part_afield.go → core/vals/flds/part_sfield.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField.go // File name sfield.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -30,48 +30,45 @@ import (
type ( type (
partAField struct { partSField struct {
name string name string
} }
) )
func makePartAField(name string) partAField { func makePartSField(name string) partSField {
//checkFieldName(name) //checkFieldName(name)
return partAField{ name: name } return partSField{ name: name }
} }
func (f partAField) Name () string { func (f partSField) Name () string {
return f.name } return f.name }
func (f partAField) Bool () (bool,bool) { func (f partSField) Bool () (bool,bool) {
return false,false } return false,false }
func (f partAField) String () (string,bool) { func (f partSField) String () (string,bool) {
return "",false } return "",false }
func (f partAField) Signed () (int,bool) { func (f partSField) Signed () (int,bool) {
return 0,false } return 0,false }
func (f partAField) Unsigned () (uint,bool) { func (f partSField) Unsigned () (uint,bool) {
return 0,false } return 0,false }
func (f partAField) Float () (float64,bool) { func (f partSField) Date () (time.Time,bool) {
return 0,false }
func (f partAField) Date () (time.Time,bool) {
return *new(time.Time),false } return *new(time.Time),false }
func (f partAField) Time () (time.Time,bool) { func (f partSField) Time () (time.Time,bool) {
return *new(time.Time),false } return *new(time.Time),false }
func (f partAField) Error () (error,bool) { func (f partSField) Error () (error,bool) {
return nil,false } return nil,false }
func (f partAField) Binary () ([]byte,bool) { func (f partSField) Binary () ([]byte,bool) {
return nil,false } return nil,false }
func (f partAField) Reflect() (reflect.Value,bool) { func (f partSField) Reflect() (reflect.Value,bool) {
return *new(reflect.Value),false } return *new(reflect.Value),false }

54
core/vals/flds/pkflds/afield_packer.go
Unescape View File

@ -1,54 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name afield_packer.go
// Created by DEV
// Modified 30/04/2024
//
// Copyright 2024 activething.com
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package pkflds
import (
"apacks"
"vals/flds"
)
func AFieldBuildPack(obuilder apacks.ObjectPackBuilder, field flds.AField) {
n := field.Name()
switch field.Kind() {
case flds.KindAny : obuilder.FieldAny(field.Name(),field.Value(),0)
case flds.KindBool :
v,_ := field.Bool()
obuilder.FieldBool (n,v,0)
case flds.KindSigned : v,_ := field.Signed(); obuilder.FieldInt64 (n,int64 (v),0)
case flds.KindUnsigned: v,_ := field.Unsigned();obuilder.FieldUInt64 (n,uint64(v),0)
case flds.KindFloat : v,_ := field.Float(); obuilder.FieldFloat64(n,v,0)
case flds.KindString : v,_ := field.String(); obuilder.FieldString (n,v,0)
case flds.KindDate : v,_ := field.Date(); obuilder.FieldDate (n,v,0)
case flds.KindTime : v,_ := field.Time(); obuilder.FieldDate (n,v,0)
case flds.KindBinary : v,_ := field.Binary(); obuilder.FieldBinary (n,v,0)
// any's
// any case KindError : v,_ := field.Error(); obuilder.FieldAny (n,v,0)
// any case KindReflect : v,_ := field.Error(); obuilder.FieldAny (n,v,0)
default:
obuilder.FieldAny(field.Name(),field.Value(),0)
}
}

57
core/vals/flds/pkflds/afields_object_packer.go
Unescape View File

@ -1,57 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name afields_packer.go
// Created by DEV
// Modified 30/04/2024
//
// Copyright 2024 activething.com
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package pkflds
import (
"apacks"
"vals/flds"
)
type (
AFieldsObjectPacker flds.AFields
)
func (f AFieldsObjectPacker) BuildPack (packer apacks.ValuePacker) error {
packer.PackObject(func (b apacks.ObjectPackBuilder, _ apacks.Flags) {
for _,fl := range f {
AFieldBuildPack(b,fl)
}
},0)
return nil
}
func AddAFieldsToPack(fbuilder apacks.ObjectPackBuilder, fields flds.AFields) {
for _, fl := range fields {
AFieldBuildPack(fbuilder, fl)
}
}

5
core/vals/flds/afield.go → core/vals/flds/sfield.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField.go // File name sfield.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -30,7 +30,7 @@ import (
type ( type (
AField interface { SField interface {
Name () string Name () string
Kind () Kind Kind () Kind
@ -41,7 +41,6 @@ type (
String () (string,bool) String () (string,bool)
Signed () (int,bool) Signed () (int,bool)
Unsigned () (uint,bool) Unsigned () (uint,bool)
Float () (float64,bool)
Date () (time.Time,bool) Date () (time.Time,bool)
Time () (time.Time,bool) Time () (time.Time,bool)
Error () (error,bool) Error () (error,bool)

38
core/vals/flds/afield_any.go → core/vals/flds/sfield_any.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_any.go // File name sfield_any.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -30,41 +30,41 @@ import (
type ( type (
AFieldAny struct { SFieldAny struct {
partAField partSField
value any value any
} }
) )
func NewAFieldAny (name string, value any) *AFieldAny { func NewSFieldAny (name string, value any) *SFieldAny {
return &AFieldAny{ return &SFieldAny{
partAField: makePartAField(name), partSField: makePartSField(name),
value : value } } value : value } }
func (_ AFieldAny) Kind () Kind { func (_ SFieldAny) Kind () Kind {
return KindAny } return KindAny }
func (f AFieldAny) Value() any { func (f SFieldAny) Value() any {
return f.value } return f.value }
func (f AFieldAny) Any () (any,bool) { func (f SFieldAny) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldAny) Bool () (bool,bool) { func (f SFieldAny) Bool () (bool,bool) {
v,ok := f.value.(bool) v,ok := f.value.(bool)
return v,ok return v,ok
} }
func (f AFieldAny) String () (string,bool) { func (f SFieldAny) String () (string,bool) {
v,ok := f.value.(string) v,ok := f.value.(string)
return v,ok return v,ok
} }
func (f AFieldAny) Signed () (int,bool) { func (f SFieldAny) Signed () (int,bool) {
switch t := f.value.(type) { switch t := f.value.(type) {
case int : return t,true case int : return t,true
case int8 : return int(t),true case int8 : return int(t),true
@ -75,7 +75,7 @@ func (f AFieldAny) Signed () (int,bool) {
} }
} }
func (f AFieldAny) Unsigned () (uint,bool) { func (f SFieldAny) Unsigned () (uint,bool) {
switch t := f.value.(type) { switch t := f.value.(type) {
case uint : return t,true case uint : return t,true
case uint8 : return uint(t),true case uint8 : return uint(t),true
@ -86,7 +86,7 @@ func (f AFieldAny) Unsigned () (uint,bool) {
} }
} }
func (f AFieldAny) Float () (float64,bool) { func (f SFieldAny) Float () (float64,bool) {
v, ok := f.value.(float64) v, ok := f.value.(float64)
if !ok { if !ok {
var f32 float32 var f32 float32
@ -98,28 +98,28 @@ func (f AFieldAny) Float () (float64,bool) {
} }
func (f AFieldAny) Date () (time.Time,bool) { func (f SFieldAny) Date () (time.Time,bool) {
v, ok := f.value.(time.Time) v, ok := f.value.(time.Time)
return v, ok return v, ok
} }
func (f AFieldAny) Time () (time.Time,bool) { func (f SFieldAny) Time () (time.Time,bool) {
v, ok := f.value.(time.Time) v, ok := f.value.(time.Time)
return v, ok return v, ok
} }
func (f AFieldAny) Error () (error,bool) { func (f SFieldAny) Error () (error,bool) {
v, ok := f.value.(error) v, ok := f.value.(error)
return v, ok return v, ok
} }
func (f AFieldAny) Binary () ([]byte,bool) { func (f SFieldAny) Binary () ([]byte,bool) {
v, ok := f.value.([]byte) v, ok := f.value.([]byte)
return v, ok return v, ok
} }
func (f AFieldAny) Reflect () (reflect.Value,bool) { func (f SFieldAny) Reflect () (reflect.Value,bool) {
v, ok := f.value.(reflect.Value) v, ok := f.value.(reflect.Value)
return v, ok return v, ok
} }

22
core/vals/flds/afield_bool.go → core/vals/flds/sfield_bool.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_bool.go // File name sfield_bool.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -27,30 +27,30 @@ package flds
type ( type (
AFieldBool struct { SFieldBool struct {
partAField partSField
value bool value bool
} }
) )
func NewAFieldBool (name string, value bool) *AFieldBool { func NewSFieldBool (name string, value bool) *SFieldBool {
return &AFieldBool{ return &SFieldBool{
partAField: makePartAField(name), partSField: makePartSField(name),
value: value } } value: value } }
func (_ AFieldBool) Kind () Kind { func (_ SFieldBool) Kind () Kind {
return KindBool } return KindSigned }
func (f AFieldBool) Value() any { func (f SFieldBool) Value() any {
return f.value } return f.value }
func (f AFieldBool) Any () (any,bool) { func (f SFieldBool) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldBool) Bool() (bool,bool) { func (f SFieldBool) Bool() (bool,bool) {
return f.value,true } return f.value,true }

20
core/vals/flds/afield_error.go → core/vals/flds/sfield_error.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_error.go // File name sfield_error.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -29,30 +29,30 @@ package flds
type ( type (
AFieldError struct { SFieldError struct {
partAField partSField
value error value error
} }
) )
func NewAFieldError(name string, value error) *AFieldError { func NewSFieldError(name string, value error) *SFieldError {
return &AFieldError{ return &SFieldError{
partAField: makePartAField(name), partSField: makePartSField(name),
value: value } } value: value } }
func (_ AFieldError) Kind () Kind { func (_ SFieldError) Kind () Kind {
return KindError } return KindError }
func (f AFieldError) Value() any { func (f SFieldError) Value() any {
return f.value } return f.value }
func (f AFieldError) Any () (any,bool) { func (f SFieldError) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldError) Error() (error,bool) { func (f SFieldError) Error() (error,bool) {
return f.value,true } return f.value,true }

20
core/vals/flds/afield_float.go → core/vals/flds/sfield_float.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_float.go // File name sfield_float.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -27,30 +27,30 @@ package flds
type ( type (
AFieldFloat struct { SFieldFloat struct {
partAField partSField
value float64 value float64
} }
) )
func NewAFieldFloat(name string, value float64) *AFieldFloat { func NewSFieldFloat(name string, value float64) *SFieldFloat {
return &AFieldFloat{ return &SFieldFloat{
partAField: makePartAField(name), partSField: makePartSField(name),
value: value } } value: value } }
func (_ AFieldFloat) Kind () Kind { func (_ SFieldFloat) Kind () Kind {
return KindFloat } return KindFloat }
func (f AFieldFloat) Value() any { func (f SFieldFloat) Value() any {
return f.value } return f.value }
func (f AFieldFloat) Any () (any,bool) { func (f SFieldFloat) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldFloat) Float() (float64,bool) { func (f SFieldFloat) Float() (float64,bool) {
return f.value,true } return f.value,true }

20
core/vals/flds/afield_reflect.go → core/vals/flds/sfield_reflect.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_reflect.go // File name sfield_reflect.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -27,30 +27,30 @@ import "reflect"
type ( type (
AFieldReflect struct { SFieldReflect struct {
partAField partSField
value reflect.Value value reflect.Value
} }
) )
func NewAFieldReflect(name string, value reflect.Value) *AFieldReflect { func NewSFieldReflect(name string, value reflect.Value) *SFieldReflect {
return &AFieldReflect{ return &SFieldReflect{
partAField: makePartAField(name), partSField: makePartSField(name),
value: value } } value: value } }
func (_ AFieldReflect) Kind () Kind { func (_ SFieldReflect) Kind () Kind {
return KindReflect } return KindReflect }
func (f AFieldReflect) Value() any { func (f SFieldReflect) Value() any {
return f.value } return f.value }
func (f AFieldReflect) Any () (any,bool) { func (f SFieldReflect) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldReflect) Reflect() (reflect.Value,bool) { func (f SFieldReflect) Reflect() (reflect.Value,bool) {
return f.value,true } return f.value,true }

20
core/vals/flds/afield_signed.go → core/vals/flds/sfield_signed.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_signed.go // File name sfield_signed.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -27,28 +27,28 @@ package flds
type ( type (
AFieldSigned struct { SFieldSigned struct {
partAField partSField
value int value int
} }
) )
func NewAFieldSigned (name string, value int) *AFieldSigned { func NewSFieldSigned (name string, value int) *SFieldSigned {
return &AFieldSigned{ return &SFieldSigned{
partAField: makePartAField(name), partSField: makePartSField(name),
value: value } } value: value } }
func (_ AFieldSigned) Kind () Kind { func (_ SFieldSigned) Kind () Kind {
return KindSigned } return KindSigned }
func (f AFieldSigned) Value() any { func (f SFieldSigned) Value() any {
return f.value } return f.value }
func (f AFieldSigned) Any () (any,bool) { func (f SFieldSigned) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldSigned) Signed() (int,bool) { func (f SFieldSigned) Signed() (int,bool) {
return f.value,true } return f.value,true }

20
core/vals/flds/afield_str.go → core/vals/flds/sfield_str.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_string.go // File name sfield_string.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -27,28 +27,28 @@ package flds
type ( type (
AFieldString struct { SFieldString struct {
partAField partSField
value string value string
} }
) )
func NewAFieldString (name string, value string) *AFieldString { func NewSFieldString (name string, value string) *SFieldString {
return &AFieldString{ return &SFieldString{
partAField: makePartAField(name), partSField: makePartSField(name),
value : value } } value : value } }
func (_ AFieldString) Kind () Kind { func (_ SFieldString) Kind () Kind {
return KindString } return KindString }
func (f AFieldString) Value() any { func (f SFieldString) Value() any {
return f.value } return f.value }
func (f AFieldString) Any () (any,bool) { func (f SFieldString) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldString) String() (string,bool) { func (f SFieldString) String() (string,bool) {
return f.value,true } return f.value,true }

20
core/vals/flds/afield_unsigned.go → core/vals/flds/sfield_unsigned.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aField_unsigned.go // File name sfield_unsigned.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -26,29 +26,29 @@ package flds
type ( type (
AFieldUnsigned struct { SFieldUnsigned struct {
partAField partSField
value uint value uint
} }
) )
func NewAFieldUnsigned(name string, value uint) *AFieldUnsigned { func NewSFieldUnsigned(name string, value uint) *SFieldUnsigned {
return &AFieldUnsigned{ return &SFieldUnsigned{
partAField: makePartAField(name), partSField: makePartSField(name),
value : value } } value : value } }
func (_ AFieldUnsigned) Kind () Kind { func (_ SFieldUnsigned) Kind () Kind {
return KindUnsigned } return KindUnsigned }
func (f AFieldUnsigned) Value() any { func (f SFieldUnsigned) Value() any {
return f.value } return f.value }
func (f AFieldUnsigned) Any () (any,bool) { func (f SFieldUnsigned) Any () (any,bool) {
return f.value,true } return f.value,true }
func (f AFieldUnsigned) Unsigned() (uint,bool) { func (f SFieldUnsigned) Unsigned() (uint,bool) {
return f.value,true } return f.value,true }

38
core/vals/flds/afields.go → core/vals/flds/sfields.go
Unescape View File

@ -2,7 +2,7 @@
// Project active2 // Project active2
// Active Thing (activething.com) git.activething.com/go // Active Thing (activething.com) git.activething.com/go
// //
// File name aFields.go // File name sfields.go
// Created by DEV // Created by DEV
// Modified 30/04/2024 // Modified 30/04/2024
// //
@ -23,24 +23,22 @@
package flds package flds
import ( import "sort"
"sort"
)
type ( type (
AFields []AField SFields []SField
) )
func (f AFields) Len () int { func (f SFields) Len () int {
return len(f) } return len(f) }
func (f AFields) Has (name string) bool { func (f SFields) Has (name string) bool {
return f.has(name) != -1 } return f.has(name) != -1 }
func (f AFields) has (name string) int { func (f SFields) has (name string) int {
for i,f := range f { for i,f := range f {
if f.Name() == name { if f.Name() == name {
return i return i
@ -49,7 +47,7 @@ func (f AFields) has (name string) int {
return -1 return -1
} }
func (f AFields) Kinds() Kind { func (f SFields) Kinds() Kind {
var k Kind var k Kind
for _,f := range f { for _,f := range f {
k|=f.Kind() k|=f.Kind()
@ -57,31 +55,21 @@ func (f AFields) Kinds() Kind {
return k return k
} }
func (f AFields) GeField (name string) AField { func (f SFields) GeField (name string) SField {
if p := f.has(name); p != -1 { if p := f.has(name); p != -1 {
return f[p] return f[p]
} }
return nil return nil
} }
func (f AFields) AddField (field AField) AFields { func (f SFields) AddField (field SField) SFields {
if field != nil { if field != nil {
return append(f,field) return append(f,field)
} }
return f return f
} }
func (f AFields) SetField (field AField) AFields { func (f SFields) DelField (name string) SFields {
if field == nil {
return f
}
if p := f.has(field.Name()); p != -1 {
return append(append(f[:p],field), f[p+1:]...)
}
return append(f,field)
}
func (f AFields) DelField (name string) AFields {
if p := f.has(name); p != -1 { if p := f.has(name); p != -1 {
return append(f[:p],f[p+1:]...) return append(f[:p],f[p+1:]...)
} }
@ -90,12 +78,12 @@ func (f AFields) DelField (name string) AFields {
func (f AFields) Sort() { func (f SFields) Sort() {
sort.Sort(f) } sort.Sort(f) }
func (f AFields) Swap(i, j int) { func (f SFields) Swap(i, j int) {
f[i], f[j] = f[j], f[i] } f[i], f[j] = f[j], f[i] }
func (f AFields) Less(i, j int) bool { func (f SFields) Less(i, j int) bool {
return f[i].Name() < f[j].Name() } return f[i].Name() < f[j].Name() }
Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.