diff --git a/base/alogs/entry.go b/base/alogs/entry.go index 0e22682..42056f0 100644 --- a/base/alogs/entry.go +++ b/base/alogs/entry.go @@ -106,8 +106,8 @@ func (e *Entry) reset () *Entry { func (e *Entry) Build(builder blds.Builder) error { builder.Object(func (ob blds.ObjectBuilder){ - ob.Field("id").Uint64(e.Id) - ob.Field("date").Time(e.Date) + ob.field("id").Uint64(e.Id) + ob.field("date").Time(e.Date) for _,f := range e.Fields { f.BuildField(ob) } diff --git a/base/apack/active.go b/base/apack/active.go index 438d500..d649785 100644 --- a/base/apack/active.go +++ b/base/apack/active.go @@ -24,7 +24,9 @@ package apack -import "errs" +import ( + "errs" +) const( diff --git a/base/apack/flags.go b/base/apack/flags.go index ed8897b..e623bd3 100644 --- a/base/apack/flags.go +++ b/base/apack/flags.go @@ -211,6 +211,10 @@ func FlagsWithString(flags string, onOption func(string) Flags) Flags { return nf } + + + + func FlagsFromPackTag (raw reflect.StructTag) (string,Flags,bool) { return FlagsFromTag(raw,TagKey,FlagByName) } diff --git a/base/apack/pkjson/active.go b/base/apack/pkjson/active.go index 4c13f78..bbe4dd7 100644 --- a/base/apack/pkjson/active.go +++ b/base/apack/pkjson/active.go @@ -31,6 +31,7 @@ import ( "encoding/json" "reflect" "strconv" + "sync" "time" ) @@ -53,6 +54,7 @@ var ( textMarshalerType reflect.Type keyStringer *keyStringer + packersCache sync.Map } { stringifyType : reflect.TypeOf((*stringify)(nil)).Elem(), diff --git a/base/apack/pkjson/builder.go b/base/apack/pkjson/builder.go index 4495273..7ec5c5e 100644 --- a/base/apack/pkjson/builder.go +++ b/base/apack/pkjson/builder.go @@ -29,6 +29,7 @@ import ( "apack/pstate" "blds" "cdcs/cjson" + "encoding/json" "reflect" "time" ) @@ -36,7 +37,7 @@ import ( type ( Builder struct { - pstate.State + *pstate.State f apack.Flags } @@ -44,19 +45,112 @@ type ( ) -func newState () *Builder { +func newBuilder (flags apack.Flags) *Builder { return &Builder{ - State : *pstate.NewState(), + State : pstate.AcquireState(), + f : flags, } } +func (b *Builder) release () { + pstate.ReleaseState(b.State) + b.State = nil +} + + +func (b *Builder) Pack (value any) []byte { + b.Any(value) + return b.B.Bytes() +} + func (b *Builder) Any (value any) { + b.checkValue() + + if value == nil { + _,_ = b.B.Write(cjson.G.NullValue) + b.postValue() + } + + if bl,is := value.(blds.Buildable); is { + bl.Build(b) + b.postValue() + return + } + + if jm,is := value.(json.Marshaler); is { + dt,er := jm.MarshalJSON() + if er != nil { + b.SetError(er) + return + } + b.B.W(dt) + b.postValue() + return + } + + switch v := value.(type) { + case bool : b.Bool (v) + case string : b.String (v) + + case int : b.Int64(int64(v)) + case int8 : b.Int64(int64(v)) + case int16 : b.Int64(int64(v)) + case int32 : b.Int64(int64(v)) + case int64 : b.Int64(v) + + case uint : b.Uint64(uint64(v)) + case uint16 : b.Uint64(uint64(v)) + case uint32 : b.Uint64(uint64(v)) + case uintptr : b.Uint64(uint64(v)) + case uint64 : b.Uint64(v) + + case float32 : b.Float32(v) + case float64 : b.Float64(v) + + case error : b.Error(v) + + case time.Time : b.Time(v) + case time.Duration : b.Duration(v) + + case reflect.Value : packReflected(v.Type())(b,v) + + case []byte : + if b.f.Binary() { + b.Binary(v) + return + } + + case []uint : packListUInt [uint ] (b,v,b.f) + case []uint16 : packListUInt [uint16] (b,v,b.f) + case []uint32 : packListUInt [uint32] (b,v,b.f) + case []uint64 : packListUInt [uint64] (b,v,b.f) + case []int : packListInt [int ] (b,v,b.f) + case []int8 : packListInt [int8 ] (b,v,b.f) + case []int16 : packListInt [int16] (b,v,b.f) + case []int32 : packListInt [int32] (b,v,b.f) + case []int64 : packListInt [int64] (b,v,b.f) + case []float32: packListFloat[float32](b,v,b.f,32) + case []float64: packListFloat[float64](b,v,b.f,64) + + case []bool : packListBool (b,v,b.f) + case []string : packListString(b,v,b.f) + case []time.Time: packListDate (b,v,b.f) + case []time.Duration: packListInt[time.Duration](b,v,b.f) + + default: + rv := reflect.ValueOf (value) + packReflected(rv.Type())(b,rv) + } + + } + + func (b *Builder) Raw (value []byte){ b.checkValue() _,_ = b.B.Write(value) @@ -102,16 +196,18 @@ func (b *Builder) Uint64 (value uint64 ){ } func (b *Builder) Float32 (value float32){ - b.checkValue() - cjson.WriteFloat(b.B,float64(value),32,true) - b.postValue() -} + b.float(float64(value),32) } + func (b *Builder) Float64 (value float64){ + b.float(value,64) } + +func (b *Builder) float (value float64, bits int) { b.checkValue() - cjson.WriteFloat(b.B,value,64,true) + cjson.WriteFloat(b.B,value,bits,b.f.Quote()) b.postValue() } + func (b *Builder) Error (value error){ b.checkValue() if value == nil { @@ -128,28 +224,48 @@ func (b *Builder) Time (value time.Time){ b.postValue() } -func (b *Builder) Duration(value time.Duration){ b.Int64(int64(value)) } +func (b *Builder) Duration(value time.Duration){ + b.Int64(int64(value)) } -func (b *Builder) Reflect (value reflect.Value){} +func (b *Builder) Reflect (value reflect.Value){ + //todo reflect +} + + + + +func (b *Builder) List (fnc func (listBuilder blds.ListBuilder )){ + b.makeLevel(pstate.ModeList,fnc == nil,false,func(bl *Builder){ + fnc(bl) + }) +} -func (b *Builder) List (fnc func (listBuilder blds.ListBuilder )){} +func (b *Builder) Map (fnc func (mapBuilder blds.MapBuilder )){ + b.makeLevel(pstate.ModeMap,fnc == nil,false,func(bl *Builder){ + fnc(bl) + }) +} + +func (b *Builder) Object(fnc func (objBuilder blds.ObjectBuilder)){ + b.makeLevel(pstate.ModeObject,fnc == nil,false,func(bl *Builder){ + fnc(bl) + }) +} -func (b *Builder) Map (fnc func (mapBuilder blds.MapBuilder )){} -func (b *Builder) Object(fnc func (objBuilder blds.ObjectBuilder)){} -func (b *Builder) Item () blds.ValueBuilder { +func (b *Builder) Item() blds.ValueBuilder { b.checkState() - b.writeSepIf(b.Items() > 0) + b.writeSepIf(b.Current.Count > 0) return b } -func (b *Builder) Key (key any) blds.ValueBuilder { +func (b *Builder) Key(key any) blds.ValueBuilder { b.checkState() - b.writeSepIf(b.Items() > 0) + b.writeSepIf(b.Current.Count > 0) g.keyStringer.packStringifyKey(b,key) if b.IsValue = b.Err == nil; b.IsValue { @@ -158,10 +274,9 @@ func (b *Builder) Key (key any) blds.ValueBuilder { return b } - -func (b *Builder) Field (name string) blds.ValueBuilder { +func (b *Builder) Field(name string) blds.ValueBuilder { b.checkState() - b.writeSepIf(b.Items() > 0) + b.writeSepIf(b.Current.Count > 0) b.packString(name,apack.FlagScapeHTML) if b.IsValue = b.Err == nil; b.IsValue { @@ -172,6 +287,33 @@ func (b *Builder) Field (name string) blds.ValueBuilder { +func (b *Builder) makeLevel (mode pstate.Mode, isNil, isEmpty bool, maker func(builder *Builder)) { + b.checkValue() + if isNil { + b.B.WOQ(true, '"', cjson.G.NullValue) + b.postValue() + return + } + if isEmpty { + b.B.WOQ(true, '"', cjson.G.NullValue) + b.postValue() + return + } + + b.Open(pstate.ModeMap) + if b.Err != nil { + return + } + + maker(b) + + if b.Err != nil { + b.Close(mode) + b.postValue() + } +} + + func (b *Builder) checkState () { if b.Err != nil { panic(apack.G.ErrInvalidState.WithCause(b.Err)) @@ -190,7 +332,10 @@ func (b *Builder) checkValue () { func (b *Builder) postValue() { if b.Err != nil { b.IsValue = false - b.IncItems() + b.Current.Count++ + if b.Current.Mode == pstate.ModeValue { + b.Current.Mode = pstate.ModeNone + } } } @@ -199,7 +344,9 @@ func (b *Builder) writeSepIf(cond bool) { b.B.WriteByte(sep) } } +func (b *Builder) unsupportedType (rvalue reflect.Value) { +} diff --git a/base/apack/pkjson/key_stringer.go b/base/apack/pkjson/key_stringer.go index 0e9b601..2a79af3 100644 --- a/base/apack/pkjson/key_stringer.go +++ b/base/apack/pkjson/key_stringer.go @@ -89,7 +89,7 @@ func (s *keyStringer) packStringifyKey (b *Builder, key any) { me := &rMapEntry{ v: reflect.ValueOf(key) } fn := g.keyStringer.getOrBuildStringer(me.v.Type()) if fn == nil { - b.SetError(apack.G.ErrInvalidKey.WithMessage("cant convert key to string")) + b.SetError(apack.G.ErrInvalidKey.WithMessage("cant convert Key to string")) return } if er := fn(me,me.v); er != nil { diff --git a/base/apack/pkjson/packer.go b/base/apack/pkjson/packer.go index 1a3c0d8..fc389cb 100644 --- a/base/apack/pkjson/packer.go +++ b/base/apack/pkjson/packer.go @@ -26,9 +26,51 @@ package pkjson import ( "apack" + "apack/pstate" "cdcs/cjson" + "reflect" + "rsls" + "sync" + "time" ) + +type ( + + Packer struct { + f apack.Flags + } + + + PackerFnc func (packer *Packer) +) + + +func NewPacker (options ...PackerFnc) *Packer { + p := &Packer { + + } + for _,o:=range options { + o(p) + } + return p +} + + +func (p Packer) Pack (value any) rsls.Bytes { + + b := newBuilder(p.f) + b.release() + + b.Any(value) + if b.Err != nil { + return rsls.MakeBytesError(b.Err) + } + return rsls.MakeBytesSuccess(b.B.Bytes()) +} + + + func (b *Builder) packString (value string, flags apack.Flags) { if len(value) == 0 { b.B.Write2Byte('"','"') @@ -71,3 +113,150 @@ func (b *Builder) packBinary (value []byte, flags apack.Flags) { return } } + + + +func packListString (p *Builder, list []string, flags apack.Flags) { + p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){ + for i,v := range list { + if i > 0 { + p.B.WriteByte(sep) + } + p.packString(v, flags) + if p.Err != nil { + return + } + } + }) +} + + +func packListError (p *Builder, list []error, flags apack.Flags) { + p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){ + for i,v := range list { + if i > 0 { + p.B.WriteByte(sep) + } + if v == nil { + b.B.WOQ(true,'"',cjson.G.NullValue) + continue + } + p.packString(v.Error(), apack.FlagScapeHTML) + } + }) +} + + +func packListBool (p *Builder, list []bool, flags apack.Flags) { + p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){ + for i,v := range list { + if i > 0 { + p.B.WriteByte(sep) + } + cjson.WriteBool(p.B,v,flags.Quote()) + } + }) +} + + +func packListInt [T int | int8 | int16 | int32 | int64 | time.Duration](p *Builder, list []T, flags apack.Flags) { + p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){ + for i,v := range list { + if i > 0 { + p.B.WriteByte(sep) + } + cjson.WriteInt(p.B,int64(v),flags.Quote()) + } + }) +} + + +func packListUInt [T uint | uint8 | uint16 | uint32 | uint64|uintptr](p *Builder, list []T, flags apack.Flags) { + p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){ + for i,v := range list { + if i > 0 { + p.B.WriteByte(sep) + } + cjson.WriteUint(p.B,uint64(v),flags.Quote()) + } + }) +} + + +func packListFloat[T float32 | float64](p *Builder, list []T, flags apack.Flags, bits int) { + p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){ + for i,v := range list { + if i > 0 { + p.B.WriteByte(sep) + } + cjson.WriteFloat(p.B,float64(v),bits,flags.Quote()) + } + }) +} + + +func packListDate (p *Builder, list []time.Time, flags apack.Flags) { + p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){ + for i,v := range list { + if i > 0 { + p.B.WriteByte(sep) + } + cjson.WriteTime(p.B,v,flags.DateFormat(),flags.Quote()) + } + }) +} + + +func packReflected(rtype reflect.Type) func (b *Builder, v reflect.Value) { + if fn,hs := g.packersCache.Load(rtype); hs { + return fn.(func (builder *Builder,value reflect.Value)) + } + var wg sync.WaitGroup + var fn func(*Builder, reflect.Value) + + fi,ld := g.packersCache.LoadOrStore(rtype,func(builder *Builder, value reflect.Value){ + wg.Wait() + fn(builder,value) + }) + if ld { + return fi.(func(builder *Builder, value reflect.Value)) + } + + fn = makePackFn(rtype) + wg.Done() + + g.packersCache.Store(rtype,fn) + return fn +} + + +func makePackFn(rtype reflect.Type) func(b *Builder, v reflect.Value) { + switch rtype.Kind() { + + case reflect.Bool : return func(b *Builder, v reflect.Value) { b.Bool(v.Bool()) } + + case reflect.String : return func(b *Builder, v reflect.Value) { b.String(v.String()) } + + case reflect.Int, + reflect.Int8, + reflect.Int16, + reflect.Int32, + reflect.Int64 : return func(b *Builder, v reflect.Value) { b.Int64(v.Int()) } + + case reflect.Uint, + reflect.Uint8, + reflect.Uint16, + reflect.Uint32, + reflect.Uint64, + reflect.Uintptr : return func(b *Builder, v reflect.Value) { b.Uint64(v.Uint()) } + + case reflect.Float32: return func(b *Builder, v reflect.Value) { b.float(v.Float(),32) } + case reflect.Float64: return func(b *Builder, v reflect.Value) { b.float(v.Float(),64) } + + + default: + return func(b *Builder, v reflect.Value) {b.unsupportedType(v) } + } +} + + diff --git a/base/apack/pstate/active.go b/base/apack/pstate/active.go index 0c749c5..76efd85 100644 --- a/base/apack/pstate/active.go +++ b/base/apack/pstate/active.go @@ -24,12 +24,25 @@ package pstate +import "syns/pools" + var ( G = struct { + } { } + + g = struct { + levelsLen int + statePool pools.GPool[State] + }{ + levelsLen: 8, + statePool: *pools.NewGPool(pools.WithNew[State](func () *State { + return NewState() + })), + } ) diff --git a/base/apack/pstate/state.go b/base/apack/pstate/state.go index f3224ae..293394d 100644 --- a/base/apack/pstate/state.go +++ b/base/apack/pstate/state.go @@ -27,7 +27,6 @@ package pstate import ( "apack" "bfrs" - "core/tups" "crps" ) @@ -41,10 +40,12 @@ type ( IsValue bool Level int + levels []StateLevel + Current *StateLevel + Pos int Err error - levels []tups.GTuple[Mode,int] cyclesCheck map[any]struct{} Encrypter crps.Encrypter @@ -54,56 +55,75 @@ type ( ) + + +func AcquireState (options ...StateFnc) *State { + return (g.statePool.Get()).init(options) } + +func ReleaseState (state *State) { + g.statePool.Put(state.reset()) } + + + func NewState(options ...StateFnc) *State { return (&State{ - B : bfrs.AcquireABuffer(), + B : bfrs.NewABuffer(), + levels: make([]StateLevel,g.levelsLen), }).init(options) } + func (s *State) init (options []StateFnc) *State { for _,o := range options { o(s) } + s.levels[0].Ini(ModeValue,0) return s } - - -func (s *State) Items() int { - if s.Err == nil { - return -1 +func (s *State) reset () *State { + s.B.Reset() + s.key = nil + s.field = "" + s.IsValue = false + s.Level = 0 + s.Pos = 0 + s.Err = nil + s.cyclesCheck = nil + s.Encrypter = nil + for i := 0; i g.levelsLen { + s.levels = append(s.levels, *((&(StateLevel{})).Ini(mode, s.B.Len()))) + } else { + (&s.levels[s.Level]).Ini(mode, s.B.Len()) + } + s.Current = &s.levels[s.Level] } -func (s *State) Close(mode Element) { +func (s *State) Close(mode Mode) { s.Level-- if s.Level < 0 { s.SetError(apack.G.ErrStateInvalidLevel) return } - s.levels = s.levels[:len(s.levels)-1] -} - - -func (s *State) IncItems () { - if s.Err != nil { - s.levels[s.Level].B = s.levels[s.Level].B + 1 + if s.levels[s.Level].Mode != mode { + s.SetError(apack.G.ErrInvalidNode) } + s.Current = &s.levels[s.Level] } + func (s *State) CheckCycle(ptr any) (func(),bool) { if _,hs := s.cyclesCheck[ptr]; hs { s.SetError(apack.G.ErrCircularReference) @@ -118,7 +138,7 @@ func (s *State) SetError (err error) bool { if err == nil { return false } - s.B.Reset() + s.reset() s.Err = err return true } diff --git a/base/apack/pstate/state_level.go b/base/apack/pstate/state_level.go new file mode 100644 index 0000000..e7e71fb --- /dev/null +++ b/base/apack/pstate/state_level.go @@ -0,0 +1,51 @@ +// ------------------------------------------------------------------------ +// 🚀 Project active3 +// 🔗 Active Thing (activething.com) git.activething.com/go +// +// File name state_level.go +// ✍️ Created by DEV +// 📅 Modified 12/05/2024 +// +// 🔒 Copyright 2024 activething.com +// +// 📜 LICENSE -------------------------------------------------------------- +// 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 pstate + + +type ( + + StateLevel struct { + Start int + Pos int + Count int + Mode Mode + Name string + Key any + } + +) + + +func (s *StateLevel) Ini (mode Mode, start int) *StateLevel { + s.Mode = mode + s.Start= start + s.Pos = 0 + s.Count= 0 + s.Name = "" + s.Key = nil + return s +} + diff --git a/core/blds/list_builder.go b/core/blds/list_builder.go index 09d2cff..5607ea1 100644 --- a/core/blds/list_builder.go +++ b/core/blds/list_builder.go @@ -28,7 +28,7 @@ package blds type ( // ListBuilder es una interfaz que define el método Item para construir listas. ListBuilder interface { - Item () ValueBuilder + Item() ValueBuilder } diff --git a/core/blds/map_builder.go b/core/blds/map_builder.go index 3ba0533..d662b3c 100644 --- a/core/blds/map_builder.go +++ b/core/blds/map_builder.go @@ -28,6 +28,6 @@ type ( // MapBuilder es una interfaz que define el método Key para construir mapas. MapBuilder interface { - Key (key any) ValueBuilder + Key(key any) ValueBuilder } ) \ No newline at end of file diff --git a/core/blds/object_builder.go b/core/blds/object_builder.go index c7a07d1..d0ce1f7 100644 --- a/core/blds/object_builder.go +++ b/core/blds/object_builder.go @@ -30,7 +30,7 @@ type ( // ObjectBuilder es una interfaz que define el método Field para construir objetos. ObjectBuilder interface { - Field (name string) ValueBuilder + Field(name string) ValueBuilder } ) diff --git a/core/blds/value_builder.go b/core/blds/value_builder.go index db05858..e8f0e20 100644 --- a/core/blds/value_builder.go +++ b/core/blds/value_builder.go @@ -49,11 +49,11 @@ type ( Int32 (value int32) Int64 (value int64) - Uint (value uint ) - Uint8 (value uint8 ) - Uint16 (value uint16) - Uint32 (value uint32) - Uint64 (value uint64) + Uint (value uint ) + Uint8 (value uint8 ) + Uint16 (value uint16 ) + Uint32 (value uint32 ) + Uint64 (value uint64 ) Uintptr(value uintptr) Float32 (value float32) @@ -61,13 +61,13 @@ type ( Error (value error) - Time (value time.Time) + Time (value time.Time ) Duration(value time.Duration) Reflect (value reflect.Value) - List (func (listBuilder ListBuilder )) - Map (func (mapBuilder MapBuilder )) - Object(func (objBuilder ObjectBuilder)) + List (buildFn func (b ListBuilder )) + Map (buildFn func (b MapBuilder )) + Object(buildFn func (b ObjectBuilder)) } ) diff --git a/core/errs/efjson/json_builder.go b/core/errs/efjson/json_builder.go index a824dc1..73a1197 100644 --- a/core/errs/efjson/json_builder.go +++ b/core/errs/efjson/json_builder.go @@ -297,7 +297,7 @@ func (b *jsonBuilder) writeField (name, value, indent string, quote, coma, nl bo } // writeFieldValue -// 📋 TODO ver la posibilidad de esta logica encapsularla en los objetos Field ya que se hara frecuente la repetición +// 📋 TODO ver la posibilidad de esta logica encapsularla en los objetos field ya que se hara frecuente la repetición // de estea logica func (b *jsonBuilder) writeFieldValue (field flds.Field, level int) bool { switch field.Kind() { diff --git a/core/errs/erdata/active.go b/core/errs/erdata/active.go index 28a8435..fa3c84e 100644 --- a/core/errs/erdata/active.go +++ b/core/errs/erdata/active.go @@ -130,7 +130,7 @@ func defaultCollectors () FieldCollectors { CollectFieldFnc(func (b blds.ObjectBuilder, e error ) bool { if ms,is := e.(interface { Message() string }); is { - b.Field(fieldNameMessage).String(ms.Message()) + b.field(fieldNameMessage).String(ms.Message()) return true } return false @@ -138,7 +138,7 @@ func defaultCollectors () FieldCollectors { CollectFieldFnc(func (b blds.ObjectBuilder, e error ) bool { if in,is := e.(interface { Info () string }); is { - b.Field(fieldNameInfo).String(in.Info()) + b.field(fieldNameInfo).String(in.Info()) return true } return false @@ -146,7 +146,7 @@ func defaultCollectors () FieldCollectors { CollectFieldFnc(func (b blds.ObjectBuilder, e error ) bool { if tm,is := e.(interface { Time() time.Time }); is { - b.Field(fieldNameTime).Time(tm.Time()) + b.field(fieldNameTime).Time(tm.Time()) return true } return false @@ -154,7 +154,7 @@ func defaultCollectors () FieldCollectors { CollectFieldFnc(func (b blds.ObjectBuilder, e error ) bool { if tm,is := e.(interface { Date() time.Time }); is { - b.Field(fieldNameDate).Time(tm.Date()) + b.field(fieldNameDate).Time(tm.Date()) return true } return false @@ -162,7 +162,7 @@ func defaultCollectors () FieldCollectors { CollectFieldFnc(func (b blds.ObjectBuilder, e error ) bool { if tm,is := e.(interface { Param() string }); is { - b.Field(fieldNameParam).String(tm.Param()) + b.field(fieldNameParam).String(tm.Param()) return true } return false @@ -170,7 +170,7 @@ func defaultCollectors () FieldCollectors { CollectFieldFnc(func (b blds.ObjectBuilder, e error ) bool { if tm,is := e.(interface { User() string }); is { - b.Field(fieldNameUser).String(tm.User()) + b.field(fieldNameUser).String(tm.User()) return true } return false @@ -178,7 +178,7 @@ func defaultCollectors () FieldCollectors { CollectFieldFnc(func (b blds.ObjectBuilder, e error ) bool { if tm,is := e.(interface { Source() string }); is { - b.Field(fieldNameSource).String(tm.Source()) + b.field(fieldNameSource).String(tm.Source()) return true } return false diff --git a/core/errs/erdata/object_builder.go b/core/errs/erdata/object_builder.go index aa2d966..4192094 100644 --- a/core/errs/erdata/object_builder.go +++ b/core/errs/erdata/object_builder.go @@ -38,7 +38,7 @@ type objectBuilder struct { } -func (b *objectBuilder) Field (name string) blds.ValueBuilder { +func (b *objectBuilder) field(name string) blds.ValueBuilder { if b.nexVal { panic(G.ErrExpectedValue) } diff --git a/core/errs/err_param.go b/core/errs/err_param.go index 9833394..3510496 100644 --- a/core/errs/err_param.go +++ b/core/errs/err_param.go @@ -83,8 +83,8 @@ func (e ErrParam) Stringify (_ bool) string { } func (e ErrParam) BuildField (obuilder blds.ObjectBuilder) { - obuilder.Field("message").String(e.message) - obuilder.Field("param").String(e.param) + obuilder.field("message").String(e.message) + obuilder.field("param").String(e.param) } diff --git a/core/errs/wrap/info.go b/core/errs/wrap/info.go index 0139e40..6ca4c95 100644 --- a/core/errs/wrap/info.go +++ b/core/errs/wrap/info.go @@ -119,17 +119,17 @@ func (e Info) Build (builder blds.Builder) { builder.Object( func(b blds.ObjectBuilder) { e.BuildField(b) - b.Field("error").Error(e.error) + b.field("error").Error(e.error) }) } func (e Info) BuildField (builder blds.ObjectBuilder) { - builder.Field("message").String(e.Message) - builder.Field("info").String(e.Info) - builder.Field("desc").String(e.Desc) - builder.Field("link").String(e.Link) - builder.Field("help").String(e.Help) - builder.Field("date").Time(e.Date) + builder.field("message").String(e.Message) + builder.field("info").String(e.Info) + builder.field("desc").String(e.Desc) + builder.field("link").String(e.Link) + builder.field("help").String(e.Help) + builder.field("date").Time(e.Date) } diff --git a/core/errs/wrap/message.go b/core/errs/wrap/message.go index fffa068..c2ed014 100644 --- a/core/errs/wrap/message.go +++ b/core/errs/wrap/message.go @@ -92,4 +92,4 @@ func (e Message) Stringify (partial bool) string { func (e Message) BuildField (obuilder blds.ObjectBuilder) { - obuilder.Field("message").String(e.message) } + obuilder.field("message").String(e.message) } diff --git a/core/flds/fields.go b/core/flds/fields.go index 8ecf12b..3bf91d5 100644 --- a/core/flds/fields.go +++ b/core/flds/fields.go @@ -143,7 +143,7 @@ func (f Fields) indexOf(name string) int { func (f Fields) Build (builder blds.Builder) { builder.List(func(lb blds.ListBuilder) { for _,fl := range f { - lb.Item().Object(func(ob blds.ObjectBuilder){ + lb.item().Object(func(ob blds.ObjectBuilder){ fl.BuildField(ob) }) } diff --git a/core/flds/g_field.go b/core/flds/g_field.go index 1702d4c..3cb9da3 100644 --- a/core/flds/g_field.go +++ b/core/flds/g_field.go @@ -243,7 +243,7 @@ func (f GField[T]) Build (builder blds.Builder) { func (f GField[T]) BuildField (obuilder blds.ObjectBuilder) { - vb := obuilder.Field(f.name) + vb := obuilder.field(f.name) switch f.Kind() { case KindAny : case KindBool : vb.Bool (f.Value().(bool))