seguims con los errores

master
DEV 3 years ago
parent 0d0e220350
commit 8e20678ed0

@ -25,7 +25,7 @@ package txt
import (
"atypes/astrings"
"errs/err_fmt"
"errs/efmt"
)
@ -33,7 +33,7 @@ import (
type (
TextFmt struct {
options err_fmt.BuilderOption
options efmt.BuilderOption
timeLayout string
dateLayout string
@ -45,23 +45,23 @@ type (
valueTrans astrings.Transformers
stringTrans astrings.Transformers
defSec *err_fmt.textFmtSection
headSec *err_fmt.textFmtSection
fieldsSec *err_fmt.textFmtSection
causeSec *err_fmt.textFmtSection
multiSec *err_fmt.textFmtSection
traceSec *err_fmt.textFmtSection
defSec *efmt.textFmtSection
headSec *efmt.textFmtSection
fieldsSec *efmt.textFmtSection
causeSec *efmt.textFmtSection
multiSec *efmt.textFmtSection
traceSec *efmt.textFmtSection
fieldFormats map[string]*err_fmt.textFmtFieldFormat
fieldFormats map[string]*efmt.textFmtFieldFormat
fmeBuilder err_fmt.FrameBuilder
fmeBuilder efmt.FrameBuilder
}
)
func (f *TextFmt) Format (err error) []byte {
st := err_fmt.state{
st := efmt.state{
}
@ -73,7 +73,7 @@ func (f *TextFmt) Format (err error) []byte {
}
func (f *TextFmt) getFieldFormat (name string) *err_fmt.textFmtFieldFormat {
func (f *TextFmt) getFieldFormat (name string) *efmt.textFmtFieldFormat {
fl,_ := f.fieldFormats[name]
return fl
}

@ -25,20 +25,20 @@ package txt
import (
"ansi"
"errs/err_fmt"
"errs/efmt"
)
type (
textFmtSection struct {
ansi ansi.Code
beginFn err_fmt.BuildFnc
endFn err_fmt.BuildFnc
beginFn efmt.BuildFnc
endFn efmt.BuildFnc
}
)
func (s *textFmtSection) begin (b err_fmt.Builder) {
func (s *textFmtSection) begin (b efmt.Builder) {
if s == nil {
return
}
@ -47,7 +47,7 @@ func (s *textFmtSection) begin (b err_fmt.Builder) {
}
}
func (s *textFmtSection) end (b err_fmt.Builder) {
func (s *textFmtSection) end (b efmt.Builder) {
if s == nil {
return
}

@ -26,7 +26,7 @@ package txt
import (
"bytes"
"errors"
"errs/err_fmt"
"errs/efmt"
"errs/stack"
"fmt"
"reflect"
@ -69,8 +69,8 @@ func (s *state) AddHead(code, errType string) {
s.doHead = false
s.doFields = true
s.f.headSec.begin(s)
s.head[0]=*newTextFmtField(err_fmt.FieldNameError,code,s.f.getFieldFormat(err_fmt.FieldNameError))
s.head[1]=*newTextFmtField(err_fmt.FieldNameType,errType,s.f.getFieldFormat(err_fmt.FieldNameType))
s.head[0]=*newTextFmtField(efmt.FieldNameError,code,s.f.getFieldFormat(efmt.FieldNameError))
s.head[1]=*newTextFmtField(efmt.FieldNameType,errType,s.f.getFieldFormat(efmt.FieldNameType))
s.f.headSec.end(s)
}
}
@ -148,23 +148,23 @@ func (s *state) format (err error, level int, isWrapped, addWrap, addCause, addT
if !is {
ec = fmt.Errorf("%#v",rc)
}
*rs = *err_fmt.NewErrBuilderFormat(ec,reflect.TypeOf(er),true)
*rs = *efmt.NewErrBuilderFormat(ec,reflect.TypeOf(er),true)
}
}
}(s,&d,err,&fe)
if fb,is := err.(err_fmt.Buildable); is {
if fb,is := err.(efmt.Buildable); is {
fb.Build(s)
} else {
rt := reflect.TypeOf(err)
if rt.Kind() == reflect.Pointer {
rt = rt.Elem()
}
if eb := err_fmt.GetErrorTypeBuilder(rt); eb != nil {
if eb := efmt.GetErrorTypeBuilder(rt); eb != nil {
eb.BuildError(s,err)
} else {
eb = err_fmt.MakeErrorTypeBuilder(s,err)
err_fmt.SetErrorTypeBuilder(rt,eb)
eb = efmt.MakeErrorTypeBuilder(s,err)
efmt.SetErrorTypeBuilder(rt,eb)
}
}
@ -176,7 +176,7 @@ func (s *state) format (err error, level int, isWrapped, addWrap, addCause, addT
// o mensaje de error
rt := reflect.TypeOf(ne).String()
s.AddText(s.f.)
s.addField(fmt.Sprintf(err_fmt.fmtFieldFormatError,rt),fmt.Sprintf(err_fmt.fmtErrorFormatUnwrap,rt))
s.addField(fmt.Sprintf(efmt.fmtFieldFormatError,rt),fmt.Sprintf(efmt.fmtErrorFormatUnwrap,rt))
}
}
}
@ -239,7 +239,7 @@ func (s *state) writeMulti () {
// añadimos un field fmt-(nombre del tipo de error) con el code
// o mensaje de error
rt := reflect.TypeOf(el).String()
s.addField(fmt.Sprintf(err_fmt.fmtFieldFormatError, rt), fmt.Sprintf(err_fmt.fmtErrorTypeFormat, rt))
s.addField(fmt.Sprintf(efmt.fmtFieldFormatError, rt), fmt.Sprintf(efmt.fmtErrorTypeFormat, rt))
}
}
}
@ -269,7 +269,7 @@ func (s *state) writeCause (err error, bool addCause) {
// añadimos un field fmt-(nombre del tipo de error) con el code
// o mensaje de error
rt := reflect.TypeOf(pe).String()
s.addField(fmt.Sprintf(err_fmt.fmtFieldFormatError, rt), fmt.Sprintf(err_fmt.fmtErrorTypeFormat, rt))
s.addField(fmt.Sprintf(efmt.fmtFieldFormatError, rt), fmt.Sprintf(efmt.fmtErrorTypeFormat, rt))
}
s.f.causeSec.end(s)
}

@ -25,8 +25,8 @@
package errs
import (
"errs/erfmt"
"errs/erfmt/ftext"
"errs/efmt"
"errs/efmt/err_text_fmt"
"errs/stack"
"fmt"
"reflect"
@ -47,7 +47,7 @@ const (
var (
G = struct {
Formatter erfmt.Formatter
Formatter efmt.ErrorFormatter
ErrParam ErrCode
ErrParamNil ErrCode
@ -59,7 +59,7 @@ var (
ErrParamNil : ErrCode(CodeParamNilError),
ErrParamOutOfRange : ErrCode(CodeParamOutOfRangeError),
Formatter : ftext.DefaultFormatter(),
Formatter : err_text_fmt.DefaultFormatter(),
}
g = struct {
@ -86,7 +86,7 @@ func ToErr (err any) error {
}
func ToFormat (err error, formatter erfmt.Formatter) string {
func ToFormat (err error, formatter efmt.ErrorFormatter) string {
if formatter != nil {
return string(formatter.Format(err))
}

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

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt
type (

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

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt
import (
"fmt"

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt
const (

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt
import (
"errs/stack"

@ -21,14 +21,15 @@
// limitations under the License.
// ------------------------------------------------------------------------
package fmx
package err_text_fmt
import (
"ansi"
"errs/err_fmt"
"errs/efmt"
"errs/stack"
"fmt"
"strings"
"sync"
)
const (
@ -41,8 +42,27 @@ const (
var (
G = struct {
buildDefault sync.Once
fmtDefault *TextFormatter
}{
func defaultFrameBuilder(builder err_fmt.Builder, frame stack.Frame, num int) {
}
)
func DefaultFormatter () *TextFormatter {
G.buildDefault.Do(func() {
//c := ansi.Code(0).SetFgColor(ansi.ColorHWhite).SetBgColor(ansi.ColorHRed).SetStyle(ansi.StyleBold)
G.fmtDefault = NewTextFormatter()
})
return G.fmtDefault
}
func defaultFrameBuilder(builder efmt.Builder, frame stack.Frame, num int) {
if strings.Index(frame.Package,"runtime") != -1 {
return
}

@ -0,0 +1,150 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name fmt.go
// Created by DEV
// Modified 12/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 err_text_fmt
import (
"ansi"
"atypes/astrings"
"errs/efmt"
)
type (
TextFormatter struct {
options efmt.BuilderOption
vLayouts layouts
sections sections
nameTrans ,
valueTrans,
stringTrans astrings.Transformers
fbOnError ,
fbOnUnwrap,
fbOnCause efmt.BuilderErrorFallback
frameBuilder efmt.FrameBuilder
}
TextFormatterFnc func(f *TextFormatter)
)
func NewTextFormatter(options ...TextFormatterFnc) *TextFormatter {
fm := &TextFormatter{
options : efmt.BuilderOption(0).SetDefaults(),
vLayouts : *newLayouts(),
sections : sections{},
fbOnError : efmt.MakeErrorFallback(fbBuildError),
fbOnUnwrap: efmt.MakeErrorFallback(fbUnwrapError),
fbOnCause : efmt.MakeErrorFallback(fbUnwrapError),
frameBuilder: efmt.BuildFrameFnc(defaultFrameBuilder),
}
for _,o := range options {
o(fm)
}
return fm
}
func (f *TextFormatter) Format (err error) []byte {
if err == nil {
return nil
}
st := &state{
f : f,
}
fe := st.writeError(err,f.options.ShowWrapped(),f.options.ShowCause(),f.options.ShowTrace(),0)
if fe == nil {
return st.b.Bytes()
}
st.reset()
if fe = st.writeError(fe,false,true,false,0); fe == nil{
return st.b.Bytes()
}
return []byte(f.fbOnError(err))
}
func WithLayout (name, layout string) TextFormatterFnc {
return func(f *TextFormatter) {
switch name {
case "time":
f.vLayouts.timeLayout = layout
case "date":
f.vLayouts.dateLayout = layout
case "int":
f.vLayouts.intLayout = layout
case "float":
f.vLayouts.floatLayout = layout
case "bool":
f.vLayouts.boolLayout = layout
}
}
}
func WithShowOptions (option efmt.BuilderOption,enabled bool) TextFormatterFnc {
return func(f *TextFormatter) {
if enabled {
f.options |= option
return
}
f.options &^=option
}
}
func WithSectionFormat(sec string, before, after efmt.BuildFnc, ansiCode ansi.Code) TextFormatterFnc {
return func(f *TextFormatter) {
var s *sectionFormat
switch sec {
case "err", "" : s = &f.sections.err
case "head" : s = &f.sections.head
case "fields" : s = &f.sections.fields
case "cause" : s = &f.sections.cause
case "trace" : s = &f.sections.trace
default:
return
}
s.before = before
s.after = after
s.ansi = ansiCode
}
}

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

@ -21,11 +21,11 @@
// limitations under the License.
// ------------------------------------------------------------------------
package fmx
package err_text_fmt
import (
"ansi"
"errs/err_fmt"
"errs/efmt"
)
type (
@ -33,17 +33,17 @@ type (
sectionFormat struct {
ansi ansi.Code
before err_fmt.BuildFnc
after err_fmt.BuildFnc
before efmt.BuildFnc
after efmt.BuildFnc
}
)
func (s *sectionFormat) doBefore (b err_fmt.Builder) {
func (s *sectionFormat) doBefore (b efmt.Builder) {
if s != nil && s.before != nil {
s.before.Build(b) } }
func (s *sectionFormat) doAfter (b err_fmt.Builder) {
func (s *sectionFormat) doAfter (b efmt.Builder) {
if s != nil && s.after != nil {
s.after.Build(b) } }

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package fmx
package err_text_fmt
type (

@ -21,16 +21,17 @@
// limitations under the License.
// ------------------------------------------------------------------------
package fmx
package err_text_fmt
import (
"ansi"
"bytes"
"errors"
"errs/err_fmt"
"errs/efmt"
"errs/stack"
"fmt"
"reflect"
"time"
)
const (
@ -44,7 +45,7 @@ type (
state struct {
f *TextFmt
f *TextFormatter
b bytes.Buffer
fDone bool // se ha añadido la seccion de fields
@ -54,7 +55,7 @@ type (
)
func newState (f *TextFmt) *state {
func newState (f *TextFormatter) *state {
return &state { f : f }}
@ -76,24 +77,24 @@ func (s *state) writeError(err error, addUnwrap, addCause, addTrace bool, level
if !is {
ec = fmt.Errorf("%#v",rc)
}
*er = *err_fmt.NewErrBuilderFormat(ec,reflect.TypeOf(er),true)
*er = *efmt.NewErrBuilderFormat(ec,reflect.TypeOf(er),true)
}
}
}(s,&d,&fe)
if fe,is := err.(err_fmt.Buildable); is {
if fe,is := err.(efmt.Buildable); is {
fe.Build(s)
} else {
rt := reflect.TypeOf(err)
if rt.Kind() == reflect.Pointer {
rt = rt.Elem()
}
eb := err_fmt.GetErrorTypeBuilder(rt)
eb := efmt.GetErrorTypeBuilder(rt)
if eb != nil {
eb.BuildError(s,err)
} else {
eb := err_fmt.MakeErrorTypeBuilder(s,err)
err_fmt.SetErrorTypeBuilder(rt,eb)
eb := efmt.MakeErrorTypeBuilder(s,err)
efmt.SetErrorTypeBuilder(rt,eb)
}
}
if addUnwrap {
@ -214,42 +215,24 @@ func (s *state) writeField(name, value string) {
s.f.sections.fields.doBefore(s)
}
var cv, cn ansi.Code
n := s.f.defField.NameTrans.Apply(name)
v := s.f.defField.ValueTrans.Apply(value)
if s.f.options.ShowAnsi() {
cn = s.f.defField.NameAnsi
cv = s.f.defField.ValueAnsi
}
if ff,hs := s.f.fields[name]; hs {
n = ff.NameTrans.Apply (n)
v = ff.ValueTrans.Apply(v)
if s.f.options.ShowAnsi() {
cn = ff.NameAnsi
cv = ff.ValueAnsi
}
}
n := s.f.nameTrans.Apply(name)
v := s.f.valueTrans.Apply(value)
s.b.WriteString(s.f.vLayouts.indent)
s.b.WriteString(cn.Sprint(n))
s.b.WriteString(cn.Sprint(s.f.vLayouts.sep))
s.b.WriteString(cv.Sprint(v))
s.b.WriteString(s.ansi.Sprint(n))
s.b.WriteString(s.ansi.Sprint(s.f.vLayouts.sep))
s.b.WriteString(s.ansi.Sprint(v))
s.b.WriteByte('\n')
}
func (s *state) writeString (str string) {
str = s.f.stringTrans.Apply(str)
s.b.WriteString(s.ansi.Sprintf(str))
s.b.WriteByte('\n')
}
func (s *state) setAnsi (ansi ansi.Code) {
if s.f.options.ShowAnsi() {
s.ansi = ansi
@ -263,6 +246,67 @@ func (s *state) setAnsi (ansi ansi.Code) {
func (s *state) AddText(str string) {}
func (s *state) AddHead(errStr, errType string) {
if s.curSec > 0 {
return
}
s.f.sections.head.doBefore(s)
s.curSec = 1
s.ansi = s.f.sections.head.ansi
s.writeField(efmt.FieldNameError,errStr)
s.writeField(efmt.FieldNameType ,errType)
s.f.sections.head.doAfter (s)
}
func (s *state) AddFieldString (name string, value string ) {
if s.curSec != 1 {
return
}
s.writeField(name,value)
}
func (s *state) AddFieldInt (name string, value int ) {
if s.curSec != 1 {
return
}
s.writeField(name,fmt.Sprintf(s.f.vLayouts.intLayout,value))
}
func (s *state) AddFieldFloat (name string, value float64 ) {
if s.curSec != 1 {
return
}
s.writeField(name,fmt.Sprintf(s.f.vLayouts.floatLayout,value))
}
func (s *state) AddFieldBool (name string, value bool ) {
if s.curSec != 1 {
return
}
s.writeField(name,fmt.Sprintf(s.f.vLayouts.boolLayout,value))
}
func (s *state) AddFieldTime (name string, value time.Time) {
if s.curSec != 1 {
return
}
s.writeField(name,value.Format(s.f.vLayouts.timeLayout))
}
func (s *state) AddFieldDate (name string, value time.Time) {
if s.curSec != 1 {
return
}
s.writeField(name,value.Format(s.f.vLayouts.dateLayout))
}

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt
import "reflect"

@ -0,0 +1,42 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name error_formatter.go
// Created by DEV
// Modified 13/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 efmt
type (
ErrorFormatter interface {
Format(err error) []byte
}
FormatErrorFnc func (err error) []byte
)
func (f FormatErrorFnc) Format(err error) []byte {
return f(err) }

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt
import "reflect"

@ -21,7 +21,7 @@
// limitations under the License.
// ------------------------------------------------------------------------
package err_fmt
package efmt
import "errs/stack"

@ -1,51 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name field_format.go
// Created by DEV
// Modified 04/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 fmx
import (
"ansi"
"atypes/astrings"
)
type (
fieldFormat struct {
NameAnsi ansi.Code
ValueAnsi ansi.Code
NameTrans astrings.Transformers
ValueTrans astrings.Transformers
}
)
func (f fieldFormat) clone() fieldFormat {
return fieldFormat{
NameAnsi: f.NameAnsi,
ValueAnsi: f.ValueAnsi,
NameTrans: append(astrings.Transformers(nil),f.NameTrans...),
ValueTrans: append(astrings.Transformers(nil),f.ValueTrans...),
}
}

@ -1,97 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name fmt.go
// Created by DEV
// Modified 12/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 fmx
import (
"atypes/astrings"
"errs/err_fmt"
)
type (
TextFmt struct {
options err_fmt.BuilderOption
vLayouts layouts
sections sections
defField fieldFormat
fields map[string]*fieldFormat
stringTrans astrings.Transformers
fbOnError ,
fbOnUnwrap,
fbOnCause err_fmt.BuilderErrorFallback
frameBuilder err_fmt.FrameBuilder
}
TextFmtFnc func(f *TextFmt)
)
func NewTextFmt (options ...TextFmtFnc) *TextFmt {
fm := &TextFmt{
options : err_fmt.BuilderOption(0).SetDefaults(),
vLayouts : *newLayouts(),
sections : sections{},
fbOnError : err_fmt.MakeErrorFallback(fbBuildError),
fbOnUnwrap: err_fmt.MakeErrorFallback(fbUnwrapError),
fbOnCause : err_fmt.MakeErrorFallback(fbUnwrapError),
frameBuilder: err_fmt.BuildFrameFnc(defaultFrameBuilder),
}
for _,o := range options {
o(fm)
}
return fm
}
func (f *TextFmt) Format (err error) []byte {
if err == nil {
return nil
}
st := &state{
f : f,
}
fe := st.writeError(err,f.options.ShowWrapped(),f.options.ShowCause(),f.options.ShowTrace(),0)
if fe == nil {
return st.b.Bytes()
}
st.reset()
if fe = st.writeError(fe,false,true,false,0); fe == nil{
return st.b.Bytes()
}
return []byte(f.fbOnError(err))
}

@ -1,87 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name fmt_ops.go
// Created by DEV
// Modified 13/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 fmx
func WithLayout (name, layout string) TextFmtFnc {
return func(f *TextFmt) {
switch name {
case "time":
f.vLayouts.timeLayout = layout
case "date":
f.vLayouts.dateLayout = layout
case "int":
f.vLayouts.intLayout = layout
case "float":
f.vLayouts.floatLayout = layout
case "bool":
f.vLayouts.boolLayout = layout
}
}
}
/*
func WithShowOptions (option erfmt.BuilderOption,enabled bool) FmtTextFnc {
return func(f *ErrTextFormatter) {
if enabled {
f.options |= option
return
}
f.options &^=option
}
}
func WithSectionFormat(id int, config func (s *SectionFormat)) FmtTextFnc {
if id < DefaultSection && id > TraceSection {
return func(_ *ErrTextFormatter){}
}
return func(f *ErrTextFormatter) {
config(&f.secs[id])
}
}
func WithFieldFormat(field string, config func(format *FieldFormat)) FmtTextFnc {
return func(f *ErrTextFormatter) {
if field == "" || field == "*" {
config(&f.defFieldFormat)
return
}
if f.fieldsFormat == nil {
f.fieldsFormat = make(map[string]FieldFormat)
}
fm := FieldFormat{}
config(&fm)
if strings.Index(field,",") == -1 {
f.fieldsFormat[field]=fm
return
}
for _,fn := range strings.SplitAfter(field,",") {
f.fieldsFormat[fn]=fm
}
}
}
*/

@ -1,91 +0,0 @@
// ------------------------------------------------------------------------
// Project active2
// Active Thing (activething.com) git.activething.com/go
//
// File name state_builder.go
// Created by DEV
// Modified 12/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 fmx
import (
"errs/err_fmt"
"fmt"
"time"
)
func (s *state) AddText(str string) {}
func (s *state) AddHead(errStr, errType string) {
if s.curSec > 0 {
return
}
s.f.sections.head.doBefore(s)
s.curSec = 1
s.ansi = s.f.sections.head.ansi
s.writeField(err_fmt.FieldNameError,errStr)
s.writeField(err_fmt.FieldNameType ,errType)
s.f.sections.head.doAfter (s)
}
func (s *state) AddFieldString (name string, value string ) {
if s.curSec != 1 {
return
}
s.writeField(name,value)
}
func (s *state) AddFieldInt (name string, value int ) {
if s.curSec != 1 {
return
}
s.writeField(name,fmt.Sprintf(s.f.vLayouts.intLayout,value))
}
func (s *state) AddFieldFloat (name string, value float64 ) {
if s.curSec != 1 {
return
}
s.writeField(name,fmt.Sprintf(s.f.vLayouts.floatLayout,value))
}
func (s *state) AddFieldBool (name string, value bool ) {
if s.curSec != 1 {
return
}
s.writeField(name,fmt.Sprintf(s.f.vLayouts.boolLayout,value))
}
func (s *state) AddFieldTime (name string, value time.Time) {
if s.curSec != 1 {
return
}
s.writeField(name,value.Format(s.f.vLayouts.timeLayout))
}
func (s *state) AddFieldDate (name string, value time.Time) {
if s.curSec != 1 {
return
}
s.writeField(name,value.Format(s.f.vLayouts.dateLayout))
}

@ -23,7 +23,9 @@
package errs
import "errs/erfmt"
import (
"errs/efmt"
)
type (
@ -69,7 +71,7 @@ func (e ErrMulti) WrapWithTrace(offset int) error {
func (e ErrMulti) String () string {
return string(G.Formatter.Format(e)) }
func (e ErrMulti) BuildFormat (builder erfmt.Builder) {
func (e ErrMulti) BuildFormat (builder efmt.Builder) {
builder.AddHead(CodeMultiError,"core.errs.ErrMulti") }

Loading…
Cancel
Save

Powered by TurnKey Linux.