restructurando el codigo para actualizar los packs con la nueva arquitectura del builder

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("id").Uint64(e.Id)
-		ob.Field("date").Time(e.Date)
+		ob.field("date").Time(e.Date)
 		for _,f := range e.Fields {
 			f.BuildField(ob)
 		}

base/apack/active.go

@@ -24,7 +24,9 @@
 
 package apack
 
-import "errs"
+import (
+	"errs"
+)
 
 const(
 

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

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(),

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()
+	b.float(float64(value),32) }
-	cjson.WriteFloat(b.B,float64(value),32,true)
+
-	b.postValue()
-}
 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) {
 
+}
 
 
 

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 {

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

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()
+		})),
+	}
 )
 
 

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) reset () *State {
-
+	s.B.Reset()
-func (s *State) Items() int {
+	s.key = nil
-	if s.Err == nil {
+	s.field = ""
-		return -1
+	s.IsValue = false
+	s.Level = 0
+	s.Pos  = 0
+	s.Err  = nil
+	s.cyclesCheck = nil
+	s.Encrypter = nil
+	for i := 0; i<len(s.levels); i++ {
+		(&s.levels[i]).Ini(ModeNone,0)
 	}
-	return s.levels[s.Level].B
+	s.levels = s.levels[:g.levelsLen]
+	return s
 }
 
-func (s *State) Mode () Mode {
+
-	if s.Err == nil {
+
-		return ModeNone
-	}
-	return s.levels[s.Level].A
-}
 
 
 func (s *State) Open (mode Mode) {
 	s.Level++
-	s.levels = append(s.levels,*tups.NewGTuple[Mode,int](mode,0))
+	if s.Level > 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]
+	if s.levels[s.Level].Mode != mode {
-}
+		s.SetError(apack.G.ErrInvalidNode)
-
-
-func (s *State) IncItems () {
-	if s.Err != nil {
-		s.levels[s.Level].B = s.levels[s.Level].B + 1
 	}
+	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
 }

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

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
 	}
 
 

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

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

core/blds/value_builder.go

@@ -49,11 +49,11 @@ type (
 		Int32 (value int32)
 		Int64 (value int64)
 
-		Uint   (value uint  )
+		Uint   (value uint   )
-		Uint8  (value uint8 )
+		Uint8  (value uint8  )
-		Uint16 (value uint16)
+		Uint16 (value uint16 )
-		Uint32 (value uint32)
+		Uint32 (value uint32 )
-		Uint64 (value uint64)
+		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  ))
+		List  (buildFn func (b ListBuilder  ))
-		Map   (func (mapBuilder  MapBuilder   ))
+		Map   (buildFn func (b MapBuilder   ))
-		Object(func (objBuilder  ObjectBuilder))
+		Object(buildFn func (b ObjectBuilder))
 	}
 )
 

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

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

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

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("message").String(e.message)
-	obuilder.Field("param").String(e.param)
+	obuilder.field("param").String(e.param)
 }
 
 

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("message").String(e.Message)
-	builder.Field("info").String(e.Info)
+	builder.field("info").String(e.Info)
-	builder.Field("desc").String(e.Desc)
+	builder.field("desc").String(e.Desc)
-	builder.Field("link").String(e.Link)
+	builder.field("link").String(e.Link)
-	builder.Field("help").String(e.Help)
+	builder.field("help").String(e.Help)
-	builder.Field("date").Time(e.Date)
+	builder.field("date").Time(e.Date)
 }
 
 

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

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

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