corregidos los errores de la descomposicion del git

alogs/active_logger.go

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

alogs/entry.go

@@ -27,6 +27,8 @@ import (
 	"apacks"
 	"atypes/slices"
 	"time"
+	"vals/flds"
+	"vals/flds/pkflds"
 )
 
 type (
@@ -45,6 +47,7 @@ type (
 		Error		error
 		Data 		any
 
+		Fields 		flds.AFields
 		Excludes 	slices.Strings
 	}
 
@@ -102,26 +105,11 @@ 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 {
 	packer.PackObject(func (b apacks.ObjectPackBuilder, _ apacks.Flags){
 		b.FieldUInt64("id",e.Id,0)
 		b.FieldDate("date",e.Date,0)
+		pkflds.AddAFieldsToPack(b,e.Fields)
 	},0)
 
 	return nil
@@ -151,9 +139,16 @@ func EntryWithExtender(extender EntryExtender) EntryFnc {
 		extender.ExtendEntry(e) } }
 
 
-func EntryWithField   (name string, value any, overwrite bool) EntryFnc {
-	return func(e *Entry) {
+func EntryWithField    (name string, value any) EntryFnc {
+	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)
+		}
 	}
 }
 

apacks/pkjson/active.go

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

apacks/pkjson/json_packer.go

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

apacks/pkjson/list_pack_builder.go

@@ -40,20 +40,22 @@ 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) ItemInt8  (value int8 , 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.state,int64(value),flags) }) }
-func (p *JSONPacker) ItemInt32 (value int32, flags apacks.Flags) { p.addItem(func (){ packInt(p.state,int64(value),flags) }) }
-func (p *JSONPacker) ItemInt64 (value int64, flags apacks.Flags) { p.addItem(func (){ packInt(p.state,value,flags) }) }
-
-func (p *JSONPacker) ItemUInt8  (value uint8 , 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.state,uint64(value),flags) }) }
-func (p *JSONPacker) ItemUInt32 (value uint32, flags apacks.Flags){ p.addItem(func (){ packUInt(p.state,uint64(value),flags) }) }
-func (p *JSONPacker) ItemUInt64 (value uint64, flags apacks.Flags){ p.addItem(func (){ packUInt(p.state,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) ItemDate 	(value time.Time, flags apacks.Flags) { p.addItem(func(){ packDate(p.state,value,flags); p.state.Inc() })}
+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,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,int64(value),flags) }) }
+func (p *JSONPacker) ItemInt64 (value int64, flags apacks.Flags) { p.addItem(func (){ packInt(p,value,flags) }) }
+
+func (p *JSONPacker) ItemUInt   (value uint  , flags apacks.Flags){ p.addItem(func (){ packUInt(p,uint64(value),flags) }) }
+func (p *JSONPacker) ItemUInt8  (value uint8 , 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,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,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,value,flags); p.state.Inc() })}
 
 
 func (p *JSONPacker) ItemList  (builder func(apacks.ListPackBuilder, apacks.Flags), flags apacks.Flags) {

apacks/pkjson/object_pack_builder.go

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

apacks/pkjson/rpacker.go

@@ -25,6 +25,7 @@ package pkjson
 
 import (
 	"apacks"
+	"fmt"
 	"reflect"
 	"sync"
 )
@@ -33,7 +34,9 @@ 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)
 
 )
 
@@ -49,7 +52,7 @@ func rTypePacker (rtype reflect.Type) rPackerFnc {
 
 	wg.Add(1)
 
-	fi,ld := g.packersCache.LoadOrStore(rtype, rPackerFnc(func (e *apacks.State, v reflect.Value, f apacks.Flags) {
+	fi,ld := g.packersCache.LoadOrStore(rtype, rPackerFnc(func (e *JSONPacker, v reflect.Value, f apacks.Flags) {
 		wg.Wait()
 		fn(e,v,f)
 	}))
@@ -66,22 +69,29 @@ 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() {
-	case reflect.Bool   : return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packBool  (s,v.Bool  (),f )}
-	case reflect.String : return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packString(s,v.String(),f )}
+	case reflect.Bool   : return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packBool  (p,v.Bool  (),f )}
+	case reflect.String : return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packString(p,v.String(),f )}
 	case reflect.Int,
 		reflect.Int8,
 		reflect.Int16,
 		reflect.Int32,
-		reflect.Int64	: return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packInt   (s,v.Int   (),f )}
+		reflect.Int64	: return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packInt   (p,v.Int   (),f )}
 	case reflect.Uint,
 		reflect.Uint8,
 		reflect.Uint16,
 		reflect.Uint32,
-		reflect.Uint64  : return func(s *apacks.State, v reflect.Value, f apacks.Flags) { packUInt  (s,v.Uint  (),f )}
-	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(s *apacks.State, v reflect.Value, f apacks.Flags) { packFloatString(s,v.Float(),f,64) }
+		reflect.Uint64  : return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packUInt  (p,v.Uint  (),f )}
+	case reflect.Float32: return func(p *JSONPacker, v reflect.Value, f apacks.Flags) { packFloatString(p,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.Pointer:
 		return rPointerPacker(rtype)
@@ -106,8 +116,8 @@ func _rTypePacker(rtype reflect.Type) rPackerFnc {
 }
 
 
-func unsupportedTypePacker(state *apacks.State, _ reflect.Value, _ apacks.Flags) {
-	state.SetError(apacks.G.ErrUnsupportedType)
+func unsupportedTypePacker(p *JSONPacker, _ reflect.Value, _ apacks.Flags) {
+	p.state.SetError(apacks.G.ErrUnsupportedType)
 }
 
 

apacks/pkjson/rpacker_interface.go

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

apacks/pkjson/rpacker_list.go

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

apacks/pkjson/rpacker_map.go

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

apacks/pkjson/rpacker_object.go

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

apacks/pkjson/rpacker_pointer.go

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

apacks/pkjson/rpacker_value.go

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

app/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"alogs"
+	"apacks/pkjson"
 	"errs"
 	"fmt"
 	"mems"
@@ -54,67 +55,27 @@ func Append2 (_ *alogs.Entry) error {
 
 
 
-func main() {
-
-
-	var fs flds.SFields
-
-	fs = fs.AddField(flds.NewSFieldSigned("Z",1))
-	fs = fs.AddField(flds.NewSFieldSigned("a",1))
-	fs = fs.AddField(flds.NewSFieldSigned("m",1))
-	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),
+func main() {
 
-		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))
-			}
-		}),
 
+	entry := alogs.NewEntry(nil,alogs.LevelFatal|alogs.LevelDebug,"Un mensage",nil,
+		alogs.EntryWithFields(
+			flds.NewAFieldString("UnCampo","valor"),
+			flds.NewAFieldSigned("UnNumero",3),
+			flds.NewAFieldSigned("UnNumero",1)),
+		alogs.EntryWithField("Una cabncion",true),
 		)
 
-	if er != nil {
-		fmt.Print(errs.Encode(er,nil))
-		time.Sleep(500*time.Millisecond)
-		return
-	}
-
-	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())
+	res := pkjson.Pack(entry)
+	if !res.Ok() {
+		fmt.Print(errs.Encode(res.Fail(),nil))
 		return
 	}
+	fmt.Println(string(res.Value()))
 
-	for i:=0; i<3; i++ {
 
-		l.Warn("Esto es un mensage")
+}
 
-	}
 
-	//time.Sleep(1000 * time.Millisecond)
-	cl()
-*/
-}

core/errs/err_fields.go

@@ -0,0 +1,82 @@
+// ------------------------------------------------------------------------
+//   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) {
+
+}
+
+
+
+

core/vals/flds/_deprecated/afield.go

@@ -1,136 +0,0 @@
-// ------------------------------------------------------------------------
-//   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
-}
-
-

core/vals/flds/_deprecated/afields.go

@@ -1,215 +0,0 @@
-// ------------------------------------------------------------------------
-//   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
-}

core/vals/flds/active.go

@@ -23,6 +23,8 @@
 
 package flds
 
+import "reflect"
+
 const(
 
 	kindBits = 16
@@ -64,13 +66,28 @@ var (
 
 )
 
-
-/* deprecated
-func checkFieldName (name string) bool {
-	if name == "" {
-		panic(G.ErrInvalidName)
+func NewAField (name string, value any) AField {
+	switch t := value.(type) {
+	case bool   :
+		return NewAFieldBool  (name,t)
+	case []byte : return NewAFieldBinary(name,t)
+	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
-}
-
- */
+}

core/vals/flds/afield.go

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

core/vals/flds/afield_any.go

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

core/vals/flds/afield_binary.go

@@ -0,0 +1,57 @@
+// ------------------------------------------------------------------------
+//   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 }
+
+

core/vals/flds/afield_bool.go

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

core/vals/flds/afield_error.go

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

core/vals/flds/afield_float.go

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

core/vals/flds/afield_reflect.go

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

core/vals/flds/afield_signed.go

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

core/vals/flds/afield_str.go

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

core/vals/flds/afield_unsigned.go

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

core/vals/flds/afields.go

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

core/vals/flds/part_afield.go

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

core/vals/flds/pkflds/afield_packer.go

@@ -0,0 +1,54 @@
+// ------------------------------------------------------------------------
+//   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)
+	}
+}

core/vals/flds/pkflds/afields_list_packer.go

@@ -2,7 +2,7 @@
 //   Project active2
 //   Active Thing (activething.com) git.activething.com/go
 //
-//   File name  heads.go
+//   File name  afields_list_packer.go
 //   Created by DEV
 //   Modified   30/04/2024
 //
@@ -21,17 +21,29 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package _deprecated
+package pkflds
 
-import "vals/flds"
+import (
+	"apacks"
+	"vals/flds"
+)
 
 type (
 
-	head 	struct {
-		name string
-		kind flds.Kind
-		pos  int
-	}
+	AFieldsListPacker 	flds.AFields
 )
 
 
+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
+}
+
+
+

core/vals/flds/pkflds/afields_object_packer.go

@@ -0,0 +1,57 @@
+// ------------------------------------------------------------------------
+//   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)
+	}
+}
+
+
+
+