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.

master
DEV 2 years ago
parent fb7e0cab27
commit 4d42ed5798

@ -35,26 +35,26 @@ import (
const (
errFieldLogger string = "logger"
errFieldScope string = "scope"
errFieldLogger string = "logger"
errFieldScope string = "scope"
entryFieldLogger string = "logger"
entryFieldLogger string = "logger"
levelNameSep string = "|"
filterLevelName string = "level"
filterScopeName string = "scope"
)
LevelNameData string = "DATA"
LevelNameDebug string = "DEBUG"
LevelNameInfo string = "INFO"
LevelNameWarn string = "WARN"
LevelNameError string = "ERROR"
LevelNameFatal string = "FATAL"
levelNameSep string = "|"
const (
filterLevelName string = "level"
filterScopeName string = "scope"
LevelNameData string = "DATA"
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 {

@ -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
// someterla a los filtros
l.extenders.ExtendEntry(entry)
if !l.filters.Filter(entry) {
if entry.Excludes.Has(l.name) {
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.Lock()
l.w.Add(1)
_ = 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 {

@ -24,31 +24,29 @@
package alogs
import (
"errs"
"iosys"
)
type (
LoggerCore struct {
LoggerCore struct {
loggerObject
filters EntryFilters
appender EntryAppender
filters EntryFilters
appender EntryAppender
//eventos
onStartFn LoggerCoreEventFnc
onStopFn LoggerCoreEventFnc
onFlushFn LoggerCoreEventFnc
onStartFn LoggerCoreEventFnc
onStopFn LoggerCoreEventFnc
onFlushFn LoggerCoreEventFnc
onFatalFn LoggerCoreEntryFnc
onErrorFn LoggerCoreErrorFnc
onErrorFn LoggerCoreErrorFnc
onEntryFatalFn LoggerCoreEntryFnc
onEntryErrorFn LoggerCoreEntryFnc
}
LoggerCoreFnc func(l *LoggerCore)
LoggerCoreFnc func(l *LoggerCore) error
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) log(level Level, msg string, err error, options []EntryFnc) {
func (l *LoggerCore) Flush () error {
l.Lock()
if l.state != StateStarted {
l.Unlock()
return
er := l.flush()
l.Unlock()
return er
}
func (l *LoggerCore) flush () error {
if l.onFlushFn == nil {
return nil
}
if !l.level.Has(level) {
l.Unlock()
return
er := l.onFlushFn(l)
if er == nil {
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 {
l.onFatalFn(l,en)
}
func (l *LoggerCore) log(level Level, msg string, err error, options []EntryFnc) {
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) {
l.Unlock()
if !l.level.Has(entry.Level) {
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) {
a.onErrorFn = onError } }
return func(a *LoggerCore) error {
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) {
a.extenders = append(a.extenders,extender...) } }
return func(a *LoggerCore) error {
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) {
configFilters(&a.filters) } }
return func(a *LoggerCore) error {
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) {
a.appender = appender } }
return func(a *LoggerCore) error {
if a.State() != StateCreated {
return G.ErrInvalidState.WrapWithMessage("config-logger-core-with-appender")
}
a.appender = appender
return nil
}
}

@ -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 }

@ -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) {

@ -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) }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -29,11 +29,11 @@ type (
ValuePacker interface {
PackAny (value any, flags Flags)
PackAny (value any, flags Flags)
PackRaw (value []byte, flags Flags)
PackBinary (value []byte, flags Flags)
PackString (value string, flags Flags)
PackRaw (value []byte, flags Flags)
PackBinary(value []byte, 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)
PackUInt16 (value uint16, flags Flags)
PackUInt32 (value uint32, flags Flags)
PackUInt64 (value uint64, flags Flags)
PackUInt8 (value uint8 , flags Flags)
PackUInt16(value uint16, flags Flags)
PackUInt32(value uint32, flags Flags)
PackUInt64(value uint64, flags Flags)
PackFloat32 (value float32, flags Flags)
PackFloat64 (value float64, flags Flags)

@ -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)
if !rs.Ok() {
return rs.Fail()
b := mems.NewABuffer()
b.WriteString("---------------------------------------------------\n")
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.Println(errs.Encode(err,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))
}
}))
}),
)
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))))
l.AddLogger(alogs.NewLoggerCore("LoggerProblematico",alogs.LevelAll,alogs.LoggerCoreWithAppender(alogs.AppendEntryFnc(Append2))))
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("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()
}

@ -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) {
c.AddFieldString(collects.FieldNameCode,string(e)) }
func (e ErrAStrings) Collect (c erdata.Collector) {
c.AddFieldString(erdata.FieldNameCode,string(e)) }

@ -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
}

@ -25,8 +25,8 @@
package errs
import (
"errs/errf"
"errs/etext"
"errs/erfield"
"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 )
}

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

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

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

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

@ -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))
}
}

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

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

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

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

@ -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
floats []float64
nums []int
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)
case FieldKindFloat: pos = len(f.floats)
case FieldKindAny: pos = len(f.anys)
FieldKindTime : pos = len(f.dates)
case FieldKindFloat : pos = len(f.floats)
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] }

@ -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)
}

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

@ -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

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

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

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

@ -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) {}

@ -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))
}

@ -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)

@ -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)
}

@ -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) }

@ -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) }

@ -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)

@ -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) {}

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

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

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

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

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

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

@ -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:

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

@ -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) {
c.AddFieldString(collects.FieldNameCode,string(e)) }
func (e ErrMems) Collect (c erdata.Collector) {
c.AddFieldString(erdata.FieldNameCode,string(e)) }

@ -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)),
}
)

@ -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
}

@ -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
}

@ -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
}
)

@ -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 }
Loading…
Cancel
Save

Powered by TurnKey Linux.