incorporado la clase AFields para su uso generealizado para las clases que necesiten incorporar informacion estructurada de forma dinamica como por ejemplo el caso de los errores asi como el de los logs.

alogs/active.go

@@ -35,26 +35,26 @@ import (
 
 const (
 
-	errFieldLogger string = "logger"
+	errFieldLogger  string = "logger"
-	errFieldScope  string = "scope"
+	errFieldScope   string = "scope"
 
+	entryFieldLogger string = "logger"
 
-	entryFieldLogger   string = "logger"
+	levelNameSep	string = "|"
 
+	filterLevelName string = "level"
+	filterScopeName string = "scope"
+)
 
-	LevelNameData 	string =  "DATA"
+const (
-	LevelNameDebug	string =  "DEBUG"
-	LevelNameInfo 	string =  "INFO"
-	LevelNameWarn 	string =  "WARN"
-	LevelNameError	string =  "ERROR"
-	LevelNameFatal	string =  "FATAL"
-
-	levelNameSep string = "|"
-
 
 
-	filterLevelName string = "level"
+	LevelNameData 	string = "DATA"
-	filterScopeName string = "scope"
+	LevelNameDebug	string = "DEBUG"
+	LevelNameInfo 	string = "INFO"
+	LevelNameWarn 	string = "WARN"
+	LevelNameError	string = "ERROR"
+	LevelNameFatal	string = "FATAL"
 )
 
 
@@ -80,6 +80,8 @@ var (
 		FmtMsgStopErr  		string
 		FmtMsgFlushErr 		string
 
+		RootLoggerName 		string
+
 	}{
 		ErrInvalidContext 	: errs.ErrCode("invalid-context"),
 		ErrInvalidState 	: errs.ErrCode("invalid-state"),
@@ -95,11 +97,12 @@ var (
 		ScopeSep 			: '.',
 		ScopeNameTransforms : astrings.MakeTransformers("lower"),
 
-		FmtMsgLogErr		: "Error logging with logger: %s",
+		FmtMsgLogErr		: "Error logging with logger [%s]",
 		FmtMsgStartErr		: "Error starting with logger: %s",
 		FmtMsgStopErr		: "Error stopping with logger: %s",
 		FmtMsgFlushErr		: "Error flushing with logger: %s",
 
+		RootLoggerName 		: "@",
 	}
 
 	g = struct {

alogs/active_logger.go

@@ -44,6 +44,7 @@ type (
 		queue 		queue.GQueue[*Entry]
 
 		ctx       	context.Context
+		w        	sync.WaitGroup
 		asyncMode 	bool
 		entryChan 	chan *Entry
 
@@ -63,7 +64,7 @@ type (
 )
 
 
-func NewActiveLogger(name string, level Level, options ...ActiveLoggerFnc) (*ActiveLogger,error) {
+func NewActiveLogger(level Level, options ...ActiveLoggerFnc) (*ActiveLogger,error) {
 	l := &ActiveLogger{
 		queue    	  : *queue.NewGQueue[*Entry](false),
 		ctx 		  : context.Background(),
@@ -71,7 +72,7 @@ func NewActiveLogger(name string, level Level, options ...ActiveLoggerFnc) (*Act
 		onEntryErrorFn: nopEntryHandler,
 		onEntryFatalFn: nopEntryHandler,
 	}
-	l.loggerObject = *newLoggerObject(name,level,l.log)
+	l.loggerObject = *newLoggerObject(G.RootLoggerName,level,l.log)
 	for _,o := range options {
 		if er := o(l); er != nil {
 			return nil,er
@@ -185,6 +186,15 @@ func (l *ActiveLogger) AddLogger(logger Logger) error {
 }
 
 
+func (l *ActiveLogger) NewLogger(name string, level Level, options ...LoggerCoreFnc) error {
+	lg,er := NewLoggerCore(name,level,options...)
+	if er != nil {
+		return er
+	}
+	return l.AddLogger(lg)
+}
+
+
 func (l *ActiveLogger) DelLogger(name string) error {
 	l.Lock()
 	 p := l.findLogger(name)
@@ -248,7 +258,8 @@ func (l *ActiveLogger) Log  (entry *Entry) error {
 }
 
 func (l *ActiveLogger) log (level Level, msg string, err error,options []EntryFnc) {
-	_ = l.logEntry(AcquireEntry(l, level, msg, err, options...)) }
+	_ = l.logEntry(AcquireEntry(l, level, msg, err, EntryWithExtender(l.extenders)))
+}
 
 
 
@@ -265,14 +276,11 @@ func (l *ActiveLogger) logEntry(entry *Entry) error {
 		l.Unlock()
 		return nil
 	}
-	// Extendermos la entrada antes de
+	if entry.Excludes.Has(l.name) {
-	// someterla a los filtros
-	l.extenders.ExtendEntry(entry)
-	if !l.filters.Filter(entry) {
 		l.Unlock()
 		return nil
 	}
-	if entry.Excludes.Has(l.name) {
+	if !l.filters.Filter(entry) {
 		l.Unlock()
 		return nil
 	}
@@ -283,8 +291,9 @@ func (l *ActiveLogger) logEntry(entry *Entry) error {
 		return er
 	}
 
+	l.w.Add(1)
 	l.entryChan <- entry
-	l.Unlock()
+
 	return nil
 }
 
@@ -300,7 +309,6 @@ func (l *ActiveLogger) dispatchEntry(entry *Entry)  error {
 	},G.FmtMsgLogErr)
 
 	if entry.Logger == l {
-
 		if entry.Level == LevelFatal  {
 			l.onEntryFatalFn(l, entry)
 		}
@@ -309,9 +317,9 @@ func (l *ActiveLogger) dispatchEntry(entry *Entry)  error {
 		}
 		ReleaseEntry(entry)
 	}
-	if er != nil {
+
-		l.handleQueue()
+	l.handleQueue()
-	}
+
 	return er
 }
 
@@ -358,7 +366,6 @@ func (l *ActiveLogger) handleLoggers(entry *Entry, doFn func(c Logger, e *Entry)
 					EntryWithField   (entryFieldLogger,nm,true))
 			}
 			l.handleError(ne,en,co)
-
 		}
 	}
 
@@ -377,31 +384,38 @@ func (l *ActiveLogger) findLogger(name string) int {
 
 
 func (l *ActiveLogger) runLogger () {
-	var w sync.WaitGroup
+	//var w sync.WaitGroup
 	for {
 		select {
 		case  <- l.ctx.Done():
-			w.Wait()
+			l.w.Wait()
 			//Esperamos que todas las entradas sean
 			//despachadas y llamamos a Stop
 			_ = l.Stop()
 			return
 		case e,ok := <- l.entryChan:
 			if !ok {
-				w.Wait()
+				l.w.Wait()
 				return
 			}
-			w.Add(1)
+			l.w.Add(1)
-			l.Lock()
 			_ = l.dispatchEntry(e)
 			l.Unlock()
-			w.Done()
+			l.w.Done()
-
 		}
 	}
 }
 
 
+func ActiveLoggerWithLogErrors (enable bool) ActiveLoggerFnc {
+	return func(a *ActiveLogger) error {
+		if a.State() != StateCreated {
+			return G.ErrInvalidState.WrapWithMessage("config-active-logger-with-log-errors")
+		}
+		a.logErrors = enable
+		return nil
+	}
+}
 
 
 func ActiveLoggerWithFilters (configFilters EntryFiltersFnc) ActiveLoggerFnc {
@@ -467,8 +481,6 @@ func ActiveLoggerWithOnEntryFatal (onError ActiveLoggerEntryFnc) ActiveLoggerFnc
 }
 
 
-
-
 func ActiveLoggerWithExtender (extender ...EntryExtender) ActiveLoggerFnc {
 	return func(a *ActiveLogger) error {
 		if a.State() != StateCreated {

alogs/logger_core.go

@@ -24,31 +24,29 @@
 package alogs
 
 import (
+	"errs"
 	"iosys"
 )
 
 type (
 
-	LoggerCore 		struct {
+	LoggerCore 			struct {
 		loggerObject
 
-		filters 	EntryFilters
+		filters 		EntryFilters
-		appender	EntryAppender
+		appender		EntryAppender
 
-		//eventos
+		onStartFn 		LoggerCoreEventFnc
-		onStartFn 	LoggerCoreEventFnc
+		onStopFn  		LoggerCoreEventFnc
-		onStopFn  	LoggerCoreEventFnc
+		onFlushFn 		LoggerCoreEventFnc
-		onFlushFn 	LoggerCoreEventFnc
 
-		onFatalFn 	LoggerCoreEntryFnc
+		onErrorFn 		LoggerCoreErrorFnc
 
-		onErrorFn 	LoggerCoreErrorFnc
+		onEntryFatalFn 	LoggerCoreEntryFnc
+		onEntryErrorFn 	LoggerCoreEntryFnc
 	}
 
-
+	LoggerCoreFnc 		func(l *LoggerCore) error
-	LoggerCoreFnc 	func(l *LoggerCore)
-
-
 
 	LoggerCoreEventFnc	func (l *LoggerCore) error
 	LoggerCoreEntryFnc 	func (l *LoggerCore, entry *Entry)
@@ -58,7 +56,7 @@ type (
 
 
 
-func NewLoggerCore (name string, level Level, options ...LoggerCoreFnc) *LoggerCore {
+func NewLoggerCore (name string, level Level, options ...LoggerCoreFnc) (*LoggerCore,error) {
 	l := &LoggerCore {
 		appender : AppendEntryFnc(nopEntryAppender),
 		onStartFn: nopOnEvent,
@@ -66,7 +64,9 @@ func NewLoggerCore (name string, level Level, options ...LoggerCoreFnc) *LoggerC
 	}
 	l.loggerObject = *newLoggerObject(name,level,l.log)
 	for _,o := range options {
-		o(l)
+		if er:=o(l); er != nil {
+			return nil,er
+		}
 	}
 	if l.onFlushFn == nil {
 		if fl,is := l.appender.(iosys.Flusher); is {
@@ -76,7 +76,7 @@ func NewLoggerCore (name string, level Level, options ...LoggerCoreFnc) *LoggerC
 			l.onFlushFn = nopOnEvent
 		}
 	}
-	return l
+	return l,nil
 }
 
 
@@ -90,10 +90,11 @@ func (l *LoggerCore) Start () error {
 
 func (l *LoggerCore) start () error {
 	if l.state == StateStarted {
-		return nil
+		return G.ErrLoggerStarted.WrapWithFieldString(entryFieldLogger,l.name)
 	}
 	l.errors = l.errors.Reset()
 	if er := l.onStartFn(l); er != nil {
+		er = errs.WrapWithFieldString(er,entryFieldLogger,l.name)
 		l.handleError(er,nil)
 		return er
 	}
@@ -110,11 +111,13 @@ func (l *LoggerCore) Stop () error {
 
 func (l *LoggerCore) stop () error {
 	if l.state != StateStarted {
-		return G.ErrLoggerNotStarted
+
+		return G.ErrLoggerNotStarted.WrapWithFieldString(entryFieldLogger,l.name)
 	}
 	l.state = StateStopped
 	er := l.onStopFn(l)
 	if er != nil {
+		er = errs.WrapWithFieldString(er,entryFieldLogger,l.name)
 		l.handleError(er,nil)
 		return er
 	}
@@ -122,66 +125,82 @@ func (l *LoggerCore) stop () error {
 }
 
 
-
+func (l *LoggerCore) Flush () error {
-func (l *LoggerCore) log(level Level, msg string, err error, options []EntryFnc) {
 	l.Lock()
-	if l.state != StateStarted  {
+	er := l.flush()
-		l.Unlock()
+	l.Unlock()
-		return
+	return er
+}
+
+func (l *LoggerCore) flush () error {
+	if l.onFlushFn == nil {
+		return nil
 	}
-	if !l.level.Has(level) {
+	er := l.onFlushFn(l)
-		l.Unlock()
+	if er == nil {
-		return
+		return nil
 	}
+	er = errs.WrapWithFieldString(er,entryFieldLogger,l.name)
+	l.handleError(er,nil)
+	return er
+}
 
-	en := l.extenders.ExtendEntry(AcquireEntry(l,level,msg,err,options...))
-	if er := l.appender.AppendEntry(en); er != nil {
-		l.handleError(er,en)
-	}
-	l.Unlock()
 
-	if level == LevelFatal && l.onFatalFn != nil {
+func (l *LoggerCore) log(level Level, msg string, err error, options []EntryFnc) {
-		l.onFatalFn(l,en)
+	l.Lock()
-	}
+
+	en := l.extenders.ExtendEntry(AcquireEntry(l,level,msg,err,options...))
+	_ = l.handleEntry(en,true)
 
-	ReleaseEntry(en)
+	l.Unlock()
 }
 
 
 func (l *LoggerCore) Log(entry *Entry) error {
 	l.Lock()
-	if l.state != StateStarted {
+
-		l.Unlock()
+	er := l.handleEntry(entry,false)
+
+	l.Unlock()
+	return er
+}
+
+
+func (l *LoggerCore) handleEntry (entry *Entry, self bool) error {
+	if l.state != StateStarted  {
 		return G.ErrLoggerNotStarted.WrapWithFieldString(entryFieldLogger,l.name)
 	}
-	if !l.level.Has(entry.Level) || entry.Excludes.Has(l.name) || !l.filters.Filter(entry) {
+	if !l.level.Has(entry.Level) {
-		l.Unlock()
 		return nil
 	}
+	if !self {
+		if entry.Excludes.Has(l.name) || !l.filters.Filter(entry) {
+			return nil
+		}
+	}
 
 	er := l.appender.AppendEntry(entry)
-	l.Unlock()
-	return er
-}
 
+	if er != nil {
+		er = errs.WrapWithFieldString(er,errFieldLogger,l.name)
+		l.handleError(er,nil)
+	}
 
+	if self {
+		if entry.Logger == l {
+			if entry.Level == LevelFatal {
+				l.onEntryFatalFn(l, entry)
+			}
+			if entry.Level == LevelError {
+				l.onEntryErrorFn(l, entry)
+			}
+			ReleaseEntry(entry)
+		}
+	}
 
-func (l *LoggerCore) Flush () error {
-	l.Lock()
-	er := l.flush()
-	l.Unlock()
 	return er
 }
 
-func (l *LoggerCore) flush () error {
-	if l.onFlushFn != nil {
-		if er := l.onFlushFn(l); er != nil {
-			l.handleError(er,nil)
-			return er
-		}
-	}
-	return nil
-}
 
 
 func (l *LoggerCore) handleError (err error, entry *Entry) {
@@ -189,7 +208,7 @@ func (l *LoggerCore) handleError (err error, entry *Entry) {
 		return
 	}
 	l.errors = l.errors.Append(err)
-	if l.onErrorFn != nil {
+	if l.onEntryErrorFn != nil {
 		l.onErrorFn(l, entry, err)
 	}
 }
@@ -197,7 +216,7 @@ func (l *LoggerCore) handleError (err error, entry *Entry) {
 
 
 func LoggerCoreWithEvents (onStart, onStop, onFlush LoggerCoreEventFnc) LoggerCoreFnc {
-	return func(a *LoggerCore) {
+	return func(a *LoggerCore) error {
 		if onStart != nil {
 			a.onStartFn = onStart
 		}
@@ -207,32 +226,75 @@ func LoggerCoreWithEvents (onStart, onStop, onFlush LoggerCoreEventFnc) LoggerCo
 		if onFlush != nil {
 			a.onFlushFn = onFlush
 		}
+		return nil
 	}
 }
 
-func LoggerCoreWithOnFatal (onFatal LoggerCoreEntryFnc) LoggerCoreFnc {
-	return func(a *LoggerCore) {
-		a.onFatalFn = onFatal } }
-
 
 func LoggerCoreWithOnError (onError LoggerCoreErrorFnc) LoggerCoreFnc {
-	return func(a *LoggerCore) {
+	return func(a *LoggerCore) error {
-		a.onErrorFn = onError } }
+		if a.State() != StateCreated {
+			return G.ErrInvalidState.WrapWithMessage("config-logger-core-with-on-error")
+		}
+		a.onErrorFn = onError
+		return nil
+	}
+}
+
+
+func LoggerCoreWithOnEntryFatal (onFatal LoggerCoreEntryFnc) LoggerCoreFnc {
+	return func(a *LoggerCore) error {
+		if a.State() != StateCreated {
+			return G.ErrInvalidState.WrapWithMessage("config-logger-core-with-on-fatal")
+		}
+		a.onEntryFatalFn = onFatal
+		return nil
+	}
+}
+
+
+func LoggerCoreWithOnEntryError (onError LoggerCoreEntryFnc) LoggerCoreFnc {
+	return func(a *LoggerCore) error {
+		if a.State() != StateCreated {
+			return G.ErrInvalidState.WrapWithMessage("config-logger-core-with-entry-on-error")
+		}
+		a.onEntryErrorFn = onError
+		return nil
+	}
+}
 
 
 func LoggerCoreWithExtender (extender ...EntryExtender) LoggerCoreFnc {
-	return func(a *LoggerCore) {
+	return func(a *LoggerCore) error {
-		a.extenders = append(a.extenders,extender...) } }
+		if a.State() != StateCreated {
+			return G.ErrInvalidState.WrapWithMessage("config-logger-core-with-extender")
+		}
+		a.extenders = append(a.extenders,extender...)
+		return nil
+	}
+}
 
 
 func LoggerCoreWithFilters (configFilters EntryFiltersFnc) LoggerCoreFnc {
-	return func(a *LoggerCore) {
+	return func(a *LoggerCore) error {
-		configFilters(&a.filters) } }
+		if a.State() != StateCreated {
+			return G.ErrInvalidState.WrapWithMessage("config-logger-core-with-filters")
+		}
+		configFilters(&a.filters)
+		return nil
+	}
+}
 
 
 func LoggerCoreWithAppender(appender EntryAppender) LoggerCoreFnc {
-	return func(a *LoggerCore) {
+	return func(a *LoggerCore) error {
-		a.appender = appender  } }
+		if a.State() != StateCreated {
+			return G.ErrInvalidState.WrapWithMessage("config-logger-core-with-appender")
+		}
+		a.appender = appender
+		return nil
+	}
+}
 
 
 

alogs/logger_object.go

@@ -97,6 +97,20 @@ func (l *loggerObject) incCount () {
 	atomic.AddInt64(&l.count,1) }
 
 
+func (l *loggerObject) Errors () []error {
+	l.RLock()
+	ls := l.errors
+	l.RUnlock()
+	return ls
+}
+
+func (l *loggerObject) ClearErrors () {
+	l.Lock()
+	l.errors = l.errors[:0]
+	l.Unlock()
+}
+
+
 
 // Start Debe de implementarse para que cumpla con el interface Logger
 func (_ *loggerObject)Start () error { return nil }

alogs/logger_scope.go

@@ -173,7 +173,7 @@ func LoggerScopeWithMode(mode ScopeMode) LoggerScopeFnc {
 	}
 }
 
-
+/*
 func LoggerScopeWithLevel(level Level) LoggerScopeFnc {
 	return func(s *LoggerScope) {
 		if !level.isValid() {
@@ -182,6 +182,7 @@ func LoggerScopeWithLevel(level Level) LoggerScopeFnc {
 		s.level = level
 	}
 }
+*/
 
 func LoggerScopeWithExtender(extender ...EntryExtender) LoggerScopeFnc {
 	return func(s *LoggerScope) {

alogs/logjson/encoder.go

@@ -21,22 +21,22 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package ejson
+package logjson
 
 import (
 	"alogs"
-	"apacks/pjson"
+	"apacks/pkjson"
 	"results"
 )
 
 type (
 
 	EncoderJSON  struct {
-		pjson.JSONPacker
+		pkjson.JSONPacker
 	}
 )
 
 
 
 func EncodeEntry (entry *alogs.Entry) results.Bytes {
-	return pjson.Pack(entry) }
+	return pkjson.Pack(entry) }

apacks/pkjson/active.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/pkjson/json_packer.go

@@ -21,14 +21,14 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
+	"apacks"
 	"codecs/cjson"
 	"crypts"
 	"encoding/json"
 	"errs"
-	"apacks"
 	"reflect"
 	"time"
 )

apacks/pkjson/list_pack_builder.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/pkjson/map_pack_builder.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/pkjson/object_pack_builder.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/pkjson/rpacker.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/pkjson/rpacker_interface.go

@@ -21,11 +21,11 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
-	"codecs/cjson"
 	"apacks"
+	"codecs/cjson"
 	"reflect"
 )
 

apacks/pkjson/rpacker_key.go

@@ -21,12 +21,12 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
+	"apacks"
 	"encoding"
 	"math"
-	"apacks"
 	"reflect"
 	"strconv"
 )

apacks/pkjson/rpacker_list.go

@@ -21,11 +21,11 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
-	"codecs/cjson"
 	"apacks"
+	"codecs/cjson"
 	"reflect"
 )
 

apacks/pkjson/rpacker_map.go

@@ -21,11 +21,11 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
-	"codecs/cjson"
 	"apacks"
+	"codecs/cjson"
 	"reflect"
 	"sort"
 )

apacks/pkjson/rpacker_map_entry.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/pkjson/rpacker_object.go

@@ -21,11 +21,11 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
-	"mems"
 	"apacks"
+	"mems"
 	"reflect"
 	"sort"
 )

apacks/pkjson/rpacker_object_field.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/pkjson/rpacker_pointer.go

@@ -21,11 +21,11 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
-	"codecs/cjson"
 	"apacks"
+	"codecs/cjson"
 	"reflect"
 )
 

apacks/pkjson/rpacker_value.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package pjson
+package pkjson
 
 import (
 	"apacks"

apacks/value_packer.go

@@ -29,11 +29,11 @@ type (
 
 	ValuePacker interface {
 
-		PackAny    (value any, flags Flags)
+		PackAny   (value any, flags Flags)
 
-		PackRaw    (value []byte, flags Flags)
+		PackRaw   (value []byte, flags Flags)
-		PackBinary (value []byte, flags Flags)
+		PackBinary(value []byte, flags Flags)
-		PackString (value string, flags Flags)
+		PackString(value string, flags Flags)
 
 		PackBool  (value bool, flags Flags)
 
@@ -42,10 +42,10 @@ type (
 		PackInt32 (value int32, flags Flags)
 		PackInt64 (value int64, flags Flags)
 
-		PackUInt8  (value uint8 , flags Flags)
+		PackUInt8 (value uint8 , flags Flags)
-		PackUInt16 (value uint16, flags Flags)
+		PackUInt16(value uint16, flags Flags)
-		PackUInt32 (value uint32, flags Flags)
+		PackUInt32(value uint32, flags Flags)
-		PackUInt64 (value uint64, flags Flags)
+		PackUInt64(value uint64, flags Flags)
 
 		PackFloat32 (value float32, flags Flags)
 		PackFloat64 (value float64, flags Flags)

app/main.go

@@ -2,10 +2,10 @@ package main
 
 import (
 	"alogs"
-	"alogs/ejson"
 	"context"
 	"errs"
 	"fmt"
+	"mems"
 	"os"
 	"time"
 )
@@ -20,12 +20,31 @@ func Print (err error) {
 
 func Append (entry *alogs.Entry) error {
 
-	rs := ejson.EncodeEntry(entry)
+	b := mems.NewABuffer()
-	if !rs.Ok() {
+	b.WriteString("---------------------------------------------------\n")
-		return rs.Fail()
+	b.WriteString(entry.Level.String())
+	b.WriteByte('\n')
+
+	b.WriteString("Logger : ")
+	b.WriteString(entry.Logger.Name())
+	b.WriteByte('\n')
+
+	b.WriteString("Entrada : ")
+	b.WriteUIntStr(entry.Id,10)
+	b.WriteByte('\n')
+
+	b.WriteString("Mensage : ")
+	b.WriteString(entry.Message)
+	b.WriteByte('\n')
+
+	if entry.Error != nil {
+		b.WriteString("error :")
+		b.WriteString(entry.Error.Error())
+		b.WriteByte('\n')
 	}
-	fmt.Fprint(os.Stderr,string(rs.Value()))
+
-	fmt.Fprint(os.Stderr,"\n\n")
+
+	fmt.Fprint(os.Stderr,b.String())
 	return nil
 }
 
@@ -41,47 +60,45 @@ func main() {
 	cx,cl := context.WithCancel(context.Background())
 	//cl()
 
-	l,er := alogs.NewActiveLogger("Main",alogs.LevelAll,
+	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.Printf("Error producido en logger [%s] se procede a su paro\n", s.Name())
-				fmt.Println(errs.Encode(err,nil))
+				//fmt.Println(errs.Encode(err,nil))
 				fmt.Print(errs.Encode(s.Stop(),nil))
 			}
-		}))
+		}),
+
+		)
+
 	if er != nil {
 		fmt.Print(errs.Encode(er,nil))
 		time.Sleep(500*time.Millisecond)
 		return
 	}
 
-	l.AddLogger(alogs.NewLoggerCore("MiLogger",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append))))
+	l1,_:= alogs.NewLoggerCore("MiLogger",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append)))
-	l.AddLogger(alogs.NewLoggerCore("LoggerProblematico",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append2))))
+	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("saluiend\n %s\n%s\n",e,er.Error())
+		fmt.Printf("\n %s\n%s\n",e,er.Error())
 		return
 	}
 
 	for i:=0; i<3; i++ {
 
-
-
 		l.Warn("Esto es un mensage")
-		//l.Error("Esto es un mensage",errs.ErrCode("UnError"))
-		//l.Fatal("Fatalidad",errs.NewErrPanic(errs.ErrCode("unca cauisa")))
-
-		//go func() {
-		time.Sleep(1 * time.Second)
-			//cl()
-		//}()
-		//l.Stop()
-
 
 	}
-	time.Sleep(1 * time.Second)
+
+	//time.Sleep(1000 * time.Millisecond)
 	cl()
+
 }

core/atypes/astrings/err_astrings.go

@@ -24,7 +24,7 @@
 package astrings
 
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -45,7 +45,7 @@ func (e ErrAStrings) Code () string {
 
 
 
-func (e ErrAStrings) Collect (c collects.Collector) {
+func (e ErrAStrings) Collect (c erdata.Collector) {
-	c.AddFieldString(collects.FieldNameCode,string(e)) }
+	c.AddFieldString(erdata.FieldNameCode,string(e)) }
 
 

core/atypes/astrings/transformers.go

@@ -23,7 +23,7 @@
 
 package astrings
 
-import "errs/errf"
+import "errs/erfield"
 
 type (
 
@@ -39,7 +39,7 @@ func MakeTransformers (names ...string) Transformers {
 			l = append(l, t)
 			continue
 		}
-		panic(errf.NewFieldString(G.ErrTransformerNotFound,"transformer",name))
+		panic(erfield.NewFieldString(G.ErrTransformerNotFound,"transformer",name))
 	}
 	return l
 }

core/errs/active.go

@@ -25,8 +25,8 @@
 package errs
 
 import (
-	"errs/errf"
+	"errs/erfield"
-	"errs/etext"
+	"errs/ertext"
 	"errs/stack"
 	"fmt"
 )
@@ -69,7 +69,7 @@ var (
 		ErrParamNil			: ErrCode(CodeParamNilError),
 		ErrParamOutOfRange	: ErrCode(CodeParamOutOfRangeError),
 
-		Encoder				: etext.DefaultEncoder(),
+		Encoder				: ertext.DefaultEncoder(),
 	}
 
 )
@@ -236,5 +236,5 @@ func WrapWithMessage (err error, message string) error {
 
 func WrapWithFieldString (err error, name, value string) error {
 	if err == nil { return nil }
-	return *errf.NewFieldString(err,name,value )
+	return *erfield.NewFieldString(err,name,value )
 }

core/errs/erdata/active.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 import (
 	"reflect"

core/errs/erdata/collectable.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 type (
 

core/errs/erdata/collector.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 import "time"
 

core/errs/erdata/error_collector.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 type (
 

core/errs/erdata/error_data.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 import (
 	"errors"
@@ -33,14 +33,14 @@ import (
 type (
 
 
-	ErrorCollection struct {
+	ErrorData 	struct {
 		Err    		error
 		ErrStr 		string
 		Types  		[]reflect.Type
 		TypesStr	[]string
 		Fields 		Fields
 
-		Causes 		[]ErrorCollection
+		Causes 		[]ErrorData
 		Trace  		stack.Trace
 
 		Invalid 	error
@@ -48,25 +48,25 @@ type (
 )
 
 
-func NewErrorCollection(err error) *ErrorCollection {
+func NewErrorData(err error) *ErrorData {
 	if err == nil {
 		return nil
 	}
-	return &ErrorCollection{ Err: err }
+	return &ErrorData{ Err: err }
 }
 
 
-func (c *ErrorCollection) Collect (addFields,addCauses,addTrace bool) *ErrorCollection {
+func (c *ErrorData) Collect (addFields,addCauses,addTrace bool) *ErrorData {
 	c.collect(addFields,addCauses,addTrace)
 	return c
 }
 
 
-func (c *ErrorCollection) collect (addFields,addCauses,addTrace bool) *ErrorCollection {
+func (c *ErrorData) collect (addFields,addCauses,addTrace bool) *ErrorData {
 	d := false
 	ne := c.Err
 
-	defer func(ec *ErrorCollection, dn *bool){
+	defer func(ec *ErrorData, dn *bool){
 		if !(*dn) {
 			if rc := recover(); rc != nil {
 				if er,is := rc.(error); is {
@@ -95,7 +95,7 @@ func (c *ErrorCollection) collect (addFields,addCauses,addTrace bool) *ErrorColl
 		if addCauses {
 			if cs, is := ne.(interface{ Cause() error }); is {
 				if er := cs.Cause(); er != nil {
-					c.Causes = append(c.Causes, *NewErrorCollection(er).Collect(addFields,addCauses,false))
+					c.Causes = append(c.Causes, *NewErrorData(er).Collect(addFields,addCauses,false))
 				}
 			} else {
 				var ls []error
@@ -105,7 +105,7 @@ func (c *ErrorCollection) collect (addFields,addCauses,addTrace bool) *ErrorColl
 					ls = cs.Unwrap()
 				}
 				for _, er := range ls {
-					if ed := NewErrorCollection(er); ed != nil {
+					if ed := NewErrorData(er); ed != nil {
 						c.Causes = append(c.Causes, *ed.Collect(addFields,addCauses,false))
 					}
 				}

core/errs/erdata/field_collector.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 type (
 

core/errs/erdata/field_collectors.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 type (
 

core/errs/erdata/field_head.go

@@ -21,13 +21,12 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 
 type (
 
 	FieldHead 	struct {
-		WNum	int
 		Name 	string
 		Kind 	FieldKind
 		Pos  	int

core/errs/erdata/field_kind.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 
 const (

core/errs/erdata/fields.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package collects
+package erdata
 
 import (
 	"fmt"
@@ -39,8 +39,8 @@ type (
 
 		anys    []any
 		strings []string
-		ints    []int
+		nums    []int
-		floats 	[]float64
+		floats  []float64
 		dates   []time.Time
 	}
 )
@@ -70,14 +70,14 @@ func (f *Fields) AddFieldString(name string, value string) {
 }
 
 func (f *Fields) AddFieldInt   (name string, value int) {
-	f.addField(name, FieldKindInt).ints = append(f.ints, value) }
+	f.addField(name, FieldKindInt).nums = append(f.nums, value) }
 
 func (f *Fields) AddFieldBool  (name string, value bool) {
 	bv := 0
 	if value {
 		bv = 1
 	}
-	f.addField(name, FieldKindInt).ints = append(f.ints, bv)
+	f.addField(name, FieldKindInt).nums = append(f.nums, bv)
 }
 
 func (f *Fields) AddFieldFloat (name string, value float64) {
@@ -96,16 +96,15 @@ func (f *Fields) addField (name string, kind FieldKind) *Fields {
 	for i:=1; f.exists(name); i++ {
 		name = fmt.Sprintf(fmtNameDuplicated,name,i)
 	}
-
 	var pos int
 	switch kind {
 	case FieldKindBool,
-		FieldKindInt: pos = len(f.ints)
+		 FieldKindInt	: pos = len(f.nums)
 	case FieldKindString: pos = len(f.strings)
 	case FieldKindDate,
-		FieldKindTime: pos = len(f.dates)
+		 FieldKindTime	: pos = len(f.dates)
-	case FieldKindFloat: pos = len(f.floats)
+	case FieldKindFloat	: pos = len(f.floats)
-	case FieldKindAny: pos = len(f.anys)
+	case FieldKindAny	: pos = len(f.anys)
 	}
 	f.heads = append(f.heads, &FieldHead{
 		Name: name,
@@ -137,13 +136,13 @@ func (f *Fields) GetFieldValueString (head *FieldHead) string {
 	return f.strings[head.Pos] }
 
 func (f *Fields) GetFieldValueInt (head *FieldHead) int {
-	return f.ints[head.Pos] }
+	return f.nums[head.Pos] }
 
 func (f *Fields) GetFieldValueFloat (head *FieldHead) float64 {
 	return f.floats[head.Pos] }
 
 func (f *Fields) GetFieldValueBool (head *FieldHead) bool {
-	return (f.ints[head.Pos]) > 0 }
+	return (f.nums[head.Pos]) > 0 }
 
 func (f *Fields) GetFieldValueDate (head *FieldHead) time.Time {
 	return f.dates[head.Pos] }

core/errs/erfield/field_string.go

@@ -21,9 +21,9 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package errf
+package erfield
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -50,6 +50,6 @@ func (e FieldString) Unwrap () error {
 	return e.error }
 
 
-func (e FieldString) Collect (collector collects.Collector) {
+func (e FieldString) Collect (collector erdata.Collector) {
 	collector.AddFieldString(e.name,e.value)
 }

core/errs/erjson/active.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package ejson
+package erjson
 
 import "sync"
 

core/errs/erjson/json_builder.go

@@ -21,12 +21,12 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package ejson
+package erjson
 
 import (
 	"codecs/cjson"
 	"encoding/json"
-	"errs/collects"
+	"errs/erdata"
 	"fmt"
 	"mems"
 	"strings"
@@ -63,7 +63,7 @@ func newJsonBuilder (f *JSONEncoder) *jsonBuilder {
 
 
 func (b *jsonBuilder) format (err error) {
-	cl := collects.NewErrorCollection(err)
+	cl := erdata.NewErrorData(err)
 	cl.Collect(b.f.HasAddFields(),b.f.HasAddCauses(),b.f.HasAddTrace())
 
 	if cl.Invalid != nil {
@@ -75,7 +75,7 @@ func (b *jsonBuilder) format (err error) {
 }
 
 
-func (b *jsonBuilder) write (coll *collects.ErrorCollection, cont bool, level int) {
+func (b *jsonBuilder) write (coll *erdata.ErrorData, cont bool, level int) {
 	if b.invalid != nil {
 		return
 	}
@@ -120,7 +120,7 @@ func (b *jsonBuilder) write (coll *collects.ErrorCollection, cont bool, level in
 	if b.pretty {
 		b.b.WriteByte('\n')
 	}
-	b.writeField(collects.FieldNameError,coll.ErrStr, indObj,true,false, false)
+	b.writeField(erdata.FieldNameError,coll.ErrStr, indObj,true,false, false)
 
 
 	if b.f.HasAddTypes() {
@@ -132,10 +132,10 @@ func (b *jsonBuilder) write (coll *collects.ErrorCollection, cont bool, level in
 		}
 
 		if len(types) == 1 {
-			b.writeField(collects.FieldNameType, types[0].String(), indObj, true, false,false)
+			b.writeField(erdata.FieldNameType, types[0].String(), indObj, true, false,false)
 		} else {
 
-			b.writeOpen(collects.FieldNameTypes, indObj, '[', b.pretty)
+			b.writeOpen(erdata.FieldNameTypes, indObj, '[', b.pretty)
 			for i, t := range coll.TypesStr {
 				if b.pretty {
 					b.b.WriteString(ind2Obj)
@@ -165,7 +165,7 @@ func (b *jsonBuilder) write (coll *collects.ErrorCollection, cont bool, level in
 		}
 
 		coll.Fields.Sort()
-		b.writeOpen(collects.FieldNameFields, indObj, '{', b.pretty)
+		b.writeOpen(erdata.FieldNameFields, indObj, '{', b.pretty)
 		var n = 0
 
 		for _, h := range heads {
@@ -201,10 +201,10 @@ func (b *jsonBuilder) write (coll *collects.ErrorCollection, cont bool, level in
 		}
 
 		if len(causes) == 1 {
-			b.writeOpen(collects.FieldNameCause, indObj, 0, false)
+			b.writeOpen(erdata.FieldNameCause, indObj, 0, false)
 			b.write(&causes[0], true,level+1)
 		} else if len(causes) > 1 {
-			b.writeOpen(collects.FieldNameCauses, indObj, '[', b.pretty)
+			b.writeOpen(erdata.FieldNameCauses, indObj, '[', b.pretty)
 			for i, ce := range causes {
 				if i > 0 {
 					b.b.WriteByte(',')
@@ -229,7 +229,7 @@ func (b *jsonBuilder) write (coll *collects.ErrorCollection, cont bool, level in
 		if b.pretty {
 			b.b.WriteByte('\n')
 		}
-		b.writeFieldName(collects.FieldNameTrace,indObj)
+		b.writeFieldName(erdata.FieldNameTrace,indObj)
 
 		if b.encoder == nil {
 			b.encoder = json.NewEncoder(b.b)
@@ -296,9 +296,9 @@ func (b *jsonBuilder) writeField (name, value, indent string, quote, coma, nl bo
 }
 
 
-func (b *jsonBuilder) writeFieldValue (fields collects.Fields, field *collects.FieldHead, level int) bool {
+func (b *jsonBuilder) writeFieldValue (fields erdata.Fields, field *erdata.FieldHead, level int) bool {
 	switch field.Kind {
-	case collects.FieldKindFloat:
+	case erdata.FieldKindFloat:
 		n := fields.GetFieldValueFloat(field)
 		if n == 0 && b.f.HasIgnoreDefaults() {
 
@@ -307,7 +307,7 @@ func (b *jsonBuilder) writeFieldValue (fields collects.Fields, field *collects.F
 		cjson.WriteFloat(b.b,n,64,b.f.HasUseQuote())
 		return true
 
-	case collects.FieldKindInt:
+	case erdata.FieldKindInt:
 		n := fields.GetFieldValueInt(field)
 		if n == 0 && b.f.HasIgnoreDefaults() {
 			return false
@@ -315,7 +315,7 @@ func (b *jsonBuilder) writeFieldValue (fields collects.Fields, field *collects.F
 		cjson.WriteInt(b.b,int64(n),b.f.HasUseQuote())
 		return true
 
-	case collects.FieldKindString:
+	case erdata.FieldKindString:
 		s := fields.GetFieldValueString(field)
 		if len(s) == 0 && b.f.HasIgnoreDefaults() {
 			return false
@@ -323,7 +323,7 @@ func (b *jsonBuilder) writeFieldValue (fields collects.Fields, field *collects.F
 		cjson.WriteString(b.b,s,b.f.HasEscapeHTML())
 		return true
 
-	case collects.FieldKindTime:
+	case erdata.FieldKindTime:
 		d := fields.GetFieldValueDate(field)
 		if d.IsZero()  && b.f.HasIgnoreDefaults(){
 			return false
@@ -331,7 +331,7 @@ func (b *jsonBuilder) writeFieldValue (fields collects.Fields, field *collects.F
 		cjson.WriteDate(b.b,d,b.f.layout.TimeLayout,true)
 		return true
 
-	case collects.FieldKindDate:
+	case erdata.FieldKindDate:
 		d := fields.GetFieldValueDate(field)
 		if d.IsZero()  && b.f.HasIgnoreDefaults(){
 			return false
@@ -339,7 +339,7 @@ func (b *jsonBuilder) writeFieldValue (fields collects.Fields, field *collects.F
 		cjson.WriteDate(b.b,d,b.f.layout.DateLayout,true)
 		return true
 
-	case collects.FieldKindBool:
+	case erdata.FieldKindBool:
 		t := fields.GetFieldValueBool(field)
 		if !t && b.f.HasIgnoreDefaults() {
 			return false

core/errs/erjson/json_encoder.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package ejson
+package erjson
 
 type (
 

core/errs/erjson/layout.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package ejson
+package erjson
 
 import (
 	"time"

core/errs/erjson/option.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package ejson
+package erjson
 
 
 

core/errs/err_cause.go

@@ -23,7 +23,7 @@
 
 package errs
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -67,4 +67,4 @@ func (e ErrCause) String () string {
 	return string(G.Encoder.EncodeError(e)) }
 
 
-func (_ ErrCause) Collect(_ collects.Collector) {}
+func (_ ErrCause) Collect(_ erdata.Collector) {}

core/errs/err_code.go

@@ -23,7 +23,7 @@
 
 package errs
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -72,6 +72,6 @@ func (e ErrCode) String () string {
 	return string(G.Encoder.EncodeError(e)) }
 
 
-func (e ErrCode) Collect (collector collects.Collector) {
+func (e ErrCode) Collect (collector erdata.Collector) {
 	collector.AddFieldString(fieldNameCode,string(e))
 }

core/errs/err_info.go

@@ -24,7 +24,7 @@
 package errs
 
 import (
-	"errs/collects"
+	"errs/erdata"
 	"fmt"
 	"time"
 )
@@ -103,7 +103,7 @@ func (e ErrInfo) String () string {
 
 
 
-func (e ErrInfo) Collect (collector collects.Collector) {
+func (e ErrInfo) Collect (collector erdata.Collector) {
 	collector.AddFieldString(fieldNameMessage,e.message)
 	collector.AddFieldString(fieldNameInfo,e.info)
 	collector.AddFieldDate  (fieldNameDate,e.date)

core/errs/err_message.go

@@ -23,7 +23,7 @@
 
 package errs
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -71,7 +71,7 @@ func (e ErrMessage) WrapWithTrace(offset int) error {
 
 
 
-func (e ErrMessage) Collect (collector collects.Collector) {
+func (e ErrMessage) Collect (collector erdata.Collector) {
 	collector.AddFieldString(fieldNameMessage,e.message)
 
 }

core/errs/err_multi.go

@@ -23,7 +23,7 @@
 
 package errs
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -77,6 +77,6 @@ func (e ErrMulti) String () string {
 
 
 
-func (_ ErrMulti) Collect (collector collects.Collector) {
+func (_ ErrMulti) Collect (collector erdata.Collector) {
 	collector.AddFieldString(fieldNameCode,CodeMultiError) }
 

core/errs/err_panic.go

@@ -23,7 +23,7 @@
 
 package errs
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -68,5 +68,5 @@ func (e ErrPanic) String () string {
 
 
 
-func (_ ErrPanic) Collect (collector collects.Collector) {
+func (_ ErrPanic) Collect (collector erdata.Collector) {
 	collector.AddFieldString(fieldNameCode,CodePanicError) }

core/errs/err_param.go

@@ -24,7 +24,7 @@
 package errs
 
 import (
-	"errs/collects"
+	"errs/erdata"
 	"fmt"
 )
 
@@ -85,7 +85,7 @@ func (e ErrParam) String () string {
 	return string(G.Encoder.EncodeError(e)) }
 
 
-func (e ErrParam) Collect(collector collects.Collector) {
+func (e ErrParam) Collect(collector erdata.Collector) {
 	collector.AddFieldString(fieldNameCode,e.code)
 	if len(e.param) > 0 {
 		collector.AddFieldString(fieldNameParam,e.param)

core/errs/err_trace.go

@@ -24,7 +24,7 @@
 package errs
 
 import (
-	"errs/collects"
+	"errs/erdata"
 	"errs/stack"
 )
 
@@ -83,4 +83,4 @@ func (e ErrTrace) String () string {
 
 
 
-func (_ ErrTrace) Collect (_ collects.Collector) {}
+func (_ ErrTrace) Collect (_ erdata.Collector) {}

core/errs/ertext/active.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 import (
 	"ansi"

core/errs/ertext/error_fallback.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 
 type (

core/errs/ertext/layout.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 import (
 	"ansi"

core/errs/ertext/option.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 
 const (

core/errs/ertext/section.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 type (
 

core/errs/ertext/sections.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 
 type (

core/errs/ertext/text_builder.go

@@ -21,11 +21,11 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 import (
 	"ansi"
-	"errs/collects"
+	"errs/erdata"
 	"fmt"
 	"mems"
 	"strings"
@@ -95,7 +95,7 @@ func (b *TextBuilder) SetAnsi(ansiC ansi.Code) {
 
 func (b *TextBuilder) format (err error) {
 	
-	c := collects.NewErrorCollection(err)
+	c := erdata.NewErrorData(err)
 	if c.Collect(b.f.HasAddFields(), b.f.HasAddCauses(), b.f.HasAddTrace()); c.Invalid != nil {
 		//b.writeFormatError(cl.Invalid)
 		return
@@ -103,7 +103,7 @@ func (b *TextBuilder) format (err error) {
 	b.write(c, 0)
 }
 
-func (b *TextBuilder) write (c *collects.ErrorCollection, level int) {
+func (b *TextBuilder) write (c *erdata.ErrorData, level int) {
 	if b.invalid != nil {
 		return
 	}
@@ -131,12 +131,12 @@ func (b *TextBuilder) write (c *collects.ErrorCollection, level int) {
 	}(b,&d, c.Err)
 
 	f.sections.Head.begin(b)
-	b.writeFieldNameValue(collects.FieldNameError, c.ErrStr, ind)
+	b.writeFieldNameValue(erdata.FieldNameError, c.ErrStr, ind)
 	if f.HasAddTypes() {
 		if len(c.TypesStr) == 1 {
-			b.writeFieldNameValue(collects.FieldNameType,  c.TypesStr[0], ind)
+			b.writeFieldNameValue(erdata.FieldNameType,  c.TypesStr[0], ind)
 		} else {
-			b.writeFieldNameValue(collects.FieldNameTypes, strings.Join(c.TypesStr, ","), ind)
+			b.writeFieldNameValue(erdata.FieldNameTypes, strings.Join(c.TypesStr, ","), ind)
 		}
 	}
 	f.sections.Head.end(b)
@@ -226,7 +226,7 @@ func (b *TextBuilder) writeFieldNameValue(name string, value string, indent stri
 
 }
 
-func (b *TextBuilder) writeField (fields collects.Fields, field *collects.FieldHead, indent string) {
+func (b *TextBuilder) writeField (fields erdata.Fields, field *erdata.FieldHead, indent string) {
 	p := b.b.Len()
 	b.writeFieldBegin(field.Name,indent)
 	if !b.writeFieldValue(fields,field) {
@@ -237,29 +237,29 @@ func (b *TextBuilder) writeField (fields collects.Fields, field *collects.FieldH
 }
 
 
-func (b *TextBuilder) writeFieldValue (fields collects.Fields, field *collects.FieldHead) bool {
+func (b *TextBuilder) writeFieldValue (fields erdata.Fields, field *erdata.FieldHead) bool {
 
 	switch field.Kind {
-	case collects.FieldKindFloat:
+	case erdata.FieldKindFloat:
 		b.auxB.WriteFloatStr(fields.GetFieldValueFloat(field),'f',-1)
 
-	case collects.FieldKindInt:
+	case erdata.FieldKindInt:
 		b.auxB.WriteIntStr(int64(fields.GetFieldValueInt(field)),10)
 
-	case collects.FieldKindString:
+	case erdata.FieldKindString:
 		s := fields.GetFieldValueString(field)
 		if b.f.HasIgnoreEmpty() && len(s) == 0 {
 			return false
 		}
 		b.auxB.WriteString(fields.GetFieldValueString(field))
 
-	case collects.FieldKindTime:
+	case erdata.FieldKindTime:
 		b.auxB.WriteDateStr(fields.GetFieldValueDate(field), b.f.layout.TimeLayout)
 
-	case collects.FieldKindDate:
+	case erdata.FieldKindDate:
 		b.auxB.WriteDateStr(fields.GetFieldValueDate(field), b.f.layout.DateLayout)
 
-	case collects.FieldKindBool:
+	case erdata.FieldKindBool:
 		b.auxB.WriteBoolStr(fields.GetFieldValueBool(field))
 
 	default:

core/errs/ertext/text_encoder.go

@@ -21,7 +21,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
-package etext
+package ertext
 
 import (
 	"atypes/astrings"

core/mems/err_mems.go

@@ -23,7 +23,7 @@
 
 package mems
 
-import "errs/collects"
+import "errs/erdata"
 
 type (
 
@@ -44,5 +44,5 @@ func (e ErrMems) Code () string {
 
 
 
-func (e ErrMems) Collect (c collects.Collector) {
+func (e ErrMems) Collect (c erdata.Collector) {
-	c.AddFieldString(collects.FieldNameCode,string(e)) }
+	c.AddFieldString(erdata.FieldNameCode,string(e)) }

core/vals/flds/active.go

@@ -0,0 +1,46 @@
+// ------------------------------------------------------------------------
+//   Project active2
+//   Active Thing (activething.com) git.activething.com/go
+//
+//   File name  active.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 flds
+
+import "syncs/pools"
+
+var (
+
+	G = struct {
+
+
+
+	} {
+
+	}
+
+	g = struct {
+
+		pool  pools.GPool[AFields]
+
+	} {
+		pool : *pools.NewGPool[AFields](pools.WithNew(newAFields)),
+	}
+
+)

core/vals/flds/afield.go

@@ -0,0 +1,133 @@
+// ------------------------------------------------------------------------
+//   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 flds
+
+import "time"
+
+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 () 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 KindAny		: return f.fs.anys[p]
+	case KindError 	    : return f.fs.anys[p].(error)
+	case KindBool		: return f.fs.nums[p] != 0
+	case KindSigned 	: return f.fs.nums[p]
+	case KindUnsigned	: return uint(f.fs.nums[p])
+	case KindFloat		: return f.fs.floats  [p]
+	case KindString		: return f.fs.strings [p]
+	case KindDate		: return f.fs.dates	  [p]
+	case 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 != 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 != 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 != 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 != 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 != 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 != 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 != 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 != KindBinary {
+		return nil,false
+	}
+	return f.fs.binaries[f.fs.heads[f.hp].pos],true
+}
+
+

core/vals/flds/afields.go

@@ -0,0 +1,214 @@
+// ------------------------------------------------------------------------
+//   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 flds
+
+import (
+	"fmt"
+	"sort"
+	"time"
+)
+
+type (
+
+	AFields 		struct {
+		heads []head
+		kinds 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 g.pool.Get().init(options) }
+
+
+func ReleaseAFields (fields *AFields) {
+	if fields == nil {
+		return
+	}
+	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() 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,KindAny,len(f.anys)).anys = append(f.anys, value)
+	}
+}
+
+
+func (f *AFields) AddError(name string, value error) {
+	f.addField(name,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,KindBool,len(f.nums)).nums = append(f.nums,v)
+}
+
+func (f *AFields) AddSigned  (name string, value int) {
+	f.addField(name,KindSigned,len(f.nums)).nums = append(f.nums,value) }
+
+func (f *AFields) AddUnsigned(name string, value uint) {
+	f.addField(name,KindUnsigned,len(f.nums)).nums = append(f.nums,int(value)) }
+
+func (f *AFields) AddFloat(name string, value float64) {
+	f.addField(name,KindFloat,len(f.floats)).floats = append(f.floats,value) }
+
+func (f *AFields) AddDate (name string, value time.Time) {
+	f.addField(name,KindDate,len(f.dates)).dates = append(f.dates,value) }
+
+func (f *AFields) AddTime (name string, value time.Time) {
+	f.addField(name,KindTime,len(f.dates)).dates = append(f.dates,value) }
+
+func (f *AFields) AddString(name string, value string) {
+	f.addField(name,KindString,len(f.strings)).strings = append(f.strings,value) }
+
+func (f *AFields) AddBinary(name string, value []byte) {
+	f.addField(name,KindBinary,len(f.binaries)).binaries = append(f.binaries,value) }
+
+
+
+func (f *AFields) addField (name string, kind 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/heads.go

@@ -0,0 +1,36 @@
+// ------------------------------------------------------------------------
+//   Project active2
+//   Active Thing (activething.com) git.activething.com/go
+//
+//   File name  heads.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 flds
+
+
+type (
+
+	head 	struct {
+		name string
+		kind Kind
+		pos  int
+	}
+)
+
+

core/vals/flds/kind.go

@@ -0,0 +1,90 @@
+// ------------------------------------------------------------------------
+//   Project active2
+//   Active Thing (activething.com) git.activething.com/go
+//
+//   File name  kind.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 flds
+
+const(
+
+	KindAny Kind = 1 << iota
+	KindBool
+	KindSigned
+	KindUnsigned
+	KindFloat
+	KindString
+	KindDate
+	KindTime
+	KindBinary
+	KindError
+)
+
+
+type (
+
+	Kind uint8
+
+)
+
+func (k Kind) IsAny() bool {
+	return k&KindAny != 0 }
+
+func (k Kind) IsBool() bool {
+	return k&KindBool != 0 }
+
+func (k Kind) IsSigned() bool {
+	return k&KindSigned != 0 }
+
+func (k Kind) IsUnsigned() bool {
+	return k&KindUnsigned != 0 }
+
+func (k Kind) IsFloat() bool {
+	return k&KindFloat != 0 }
+
+func (k Kind) IsString() bool {
+	return k&KindString != 0 }
+
+func (k Kind) IsDate() bool {
+	return k&KindDate != 0 }
+
+func (k Kind) IsTime() bool {
+	return k&KindTime != 0 }
+
+func (k Kind) IsBinary() bool {
+	return k&KindBinary != 0 }
+
+func (k Kind) IsError() bool {
+	return k&KindError != 0 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+