summaryrefslogtreecommitdiff
path: root/vendor/codeberg.org/gruf/go-logger/format_text.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/codeberg.org/gruf/go-logger/format_text.go')
-rw-r--r--vendor/codeberg.org/gruf/go-logger/format_text.go915
1 files changed, 915 insertions, 0 deletions
diff --git a/vendor/codeberg.org/gruf/go-logger/format_text.go b/vendor/codeberg.org/gruf/go-logger/format_text.go
new file mode 100644
index 000000000..e2380884b
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-logger/format_text.go
@@ -0,0 +1,915 @@
+package logger
+
+import (
+ stdfmt "fmt"
+ "reflect"
+ "strconv"
+ "time"
+ "unsafe"
+
+ "codeberg.org/gruf/go-bytes"
+)
+
+// DefaultTextFormat is the default TextFormat instance
+var DefaultTextFormat = TextFormat{
+ Strict: false,
+ MaxDepth: 5,
+ Levels: DefaultLevels(),
+ TimeFormat: time.RFC1123,
+}
+
+// TextFormat is the default LogFormat implementation, with very similar formatting to logfmt
+type TextFormat struct {
+ // Strict defines whether to use strict key-value pair formatting, i.e. should the level
+ // timestamp and msg be formatted as key-value pairs (with forced quoting for msg)
+ Strict bool
+
+ // MaxDepth specifies the max depth of fields the formatter will iterate
+ MaxDepth uint8
+
+ // Levels defines the map of log LEVELs to level strings
+ Levels Levels
+
+ // TimeFormat specifies the time formatting to use
+ TimeFormat string
+}
+
+// fmt returns a new format instance based on receiver TextFormat and given buffer
+func (f TextFormat) fmt(buf *bytes.Buffer) format {
+ return format{
+ isKey: false,
+ depth: 0,
+ txt: f,
+ buf: buf,
+ }
+}
+
+func (f TextFormat) AppendLevel(buf *bytes.Buffer, lvl LEVEL) {
+ if f.Strict {
+ // Strict format, append level key
+ buf.WriteString(`level=`)
+ buf.WriteString(f.Levels.LevelString(lvl))
+ return
+ }
+
+ // Write level string
+ buf.WriteByte('[')
+ buf.WriteString(f.Levels.LevelString(lvl))
+ buf.WriteByte(']')
+}
+
+func (f TextFormat) AppendTimestamp(buf *bytes.Buffer, now string) {
+ if f.Strict {
+ // Strict format, use key and quote
+ buf.WriteString(`time=`)
+ appendString(f.fmt(buf), now)
+ return
+ }
+
+ // Write time as-is
+ buf.WriteString(now)
+}
+
+func (f TextFormat) AppendField(buf *bytes.Buffer, key string, value interface{}) {
+ appendKey(buf, key)
+ appendIfaceOrRValue(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendFields(buf *bytes.Buffer, fields map[string]interface{}) {
+ fmt := f.fmt(buf)
+
+ // Append individual fields
+ for key, value := range fields {
+ appendKey(buf, key)
+ appendIfaceOrRValue(fmt, value)
+ buf.WriteByte(' ')
+ }
+
+ // Drop last space
+ if len(fields) > 0 {
+ buf.Truncate(1)
+ }
+}
+
+func (f TextFormat) AppendValue(buf *bytes.Buffer, value interface{}) {
+ appendIfaceOrRValue(f.fmt(buf).IsKey(true), value)
+}
+
+func (f TextFormat) AppendValues(buf *bytes.Buffer, values []interface{}) {
+ // Prepare formatter
+ fmt := f.fmt(buf).IsKey(true)
+
+ // Append each of the values
+ for _, value := range values {
+ appendIfaceOrRValue(fmt, value)
+ buf.WriteByte(' ')
+ }
+
+ // Drop last space
+ if len(values) > 0 {
+ buf.Truncate(1)
+ }
+}
+
+func (f TextFormat) AppendArgs(buf *bytes.Buffer, args []interface{}) {
+ // Prepare formatter
+ fmt := f.fmt(buf).IsKey(true).IsRaw(true)
+
+ // Append each of the values
+ for _, arg := range args {
+ appendIfaceOrRValue(fmt, arg)
+ buf.WriteByte(' ')
+ }
+
+ // Drop last space
+ if len(args) > 0 {
+ buf.Truncate(1)
+ }
+}
+
+func (f TextFormat) AppendByteField(buf *bytes.Buffer, key string, value byte) {
+ appendKey(buf, key)
+ appendByte(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendBytesField(buf *bytes.Buffer, key string, value []byte) {
+ appendKey(buf, key)
+ appendBytes(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendStringField(buf *bytes.Buffer, key string, value string) {
+ appendKey(buf, key)
+ appendString(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendStringsField(buf *bytes.Buffer, key string, value []string) {
+ appendKey(buf, key)
+ appendStringSlice(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendBoolField(buf *bytes.Buffer, key string, value bool) {
+ appendKey(buf, key)
+ appendBool(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendBoolsField(buf *bytes.Buffer, key string, value []bool) {
+ appendKey(buf, key)
+ appendBoolSlice(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendIntField(buf *bytes.Buffer, key string, value int) {
+ appendKey(buf, key)
+ appendInt(f.fmt(buf), int64(value))
+}
+
+func (f TextFormat) AppendIntsField(buf *bytes.Buffer, key string, value []int) {
+ appendKey(buf, key)
+ appendIntSlice(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendUintField(buf *bytes.Buffer, key string, value uint) {
+ appendKey(buf, key)
+ appendUint(f.fmt(buf), uint64(value))
+}
+
+func (f TextFormat) AppendUintsField(buf *bytes.Buffer, key string, value []uint) {
+ appendKey(buf, key)
+ appendUintSlice(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendFloatField(buf *bytes.Buffer, key string, value float64) {
+ appendKey(buf, key)
+ appendFloat(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendFloatsField(buf *bytes.Buffer, key string, value []float64) {
+ appendKey(buf, key)
+ appendFloatSlice(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendTimeField(buf *bytes.Buffer, key string, value time.Time) {
+ appendKey(buf, key)
+ appendTime(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendTimesField(buf *bytes.Buffer, key string, value []time.Time) {
+ appendKey(buf, key)
+ appendTimeSlice(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendDurationField(buf *bytes.Buffer, key string, value time.Duration) {
+ appendKey(buf, key)
+ appendDuration(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendDurationsField(buf *bytes.Buffer, key string, value []time.Duration) {
+ appendKey(buf, key)
+ appendDurationSlice(f.fmt(buf), value)
+}
+
+func (f TextFormat) AppendMsg(buf *bytes.Buffer, a ...interface{}) {
+ if f.Strict {
+ // Strict format, use key and quote
+ buf.WriteString(`msg=`)
+ buf.B = strconv.AppendQuote(buf.B, stdfmt.Sprint(a...))
+ return
+ }
+
+ // Write message as-is
+ stdfmt.Fprint(buf, a...)
+}
+
+func (f TextFormat) AppendMsgf(buf *bytes.Buffer, s string, a ...interface{}) {
+ if f.Strict {
+ // Strict format, use key and quote
+ buf.WriteString(`msg=`)
+ buf.B = strconv.AppendQuote(buf.B, stdfmt.Sprintf(s, a...))
+ return
+ }
+
+ // Write message as-is
+ stdfmt.Fprintf(buf, s, a...)
+}
+
+// format is the object passed among the append___ formatting functions
+type format struct {
+ raw bool
+ isKey bool
+ depth uint8
+ txt TextFormat
+ buf *bytes.Buffer
+}
+
+// IsKey returns format instance with key set to value
+func (f format) IsKey(is bool) format {
+ return format{
+ raw: f.raw,
+ isKey: is,
+ depth: f.depth,
+ txt: f.txt,
+ buf: f.buf,
+ }
+}
+
+// IsRaw returns format instance with raw set to value
+func (f format) IsRaw(is bool) format {
+ return format{
+ raw: is,
+ isKey: f.isKey,
+ depth: f.depth,
+ txt: f.txt,
+ buf: f.buf,
+ }
+}
+
+// IncrDepth returns format instance with depth incremented
+func (f format) IncrDepth() format {
+ return format{
+ raw: f.raw,
+ isKey: f.isKey,
+ depth: f.depth + 1,
+ txt: f.txt,
+ buf: f.buf,
+ }
+}
+
+// appendByte writes a single byte to buf
+func appendByte(fmt format, b byte) {
+ fmt.buf.WriteByte(b)
+}
+
+// appendBytes writes a quoted byte slice to buf
+func appendBytes(fmt format, b []byte) {
+ if !fmt.isKey && b == nil {
+ // Values CAN be nil formatted
+ appendNilType(fmt, `[]byte`)
+ } else {
+ appendString(fmt, bytes.BytesToString(b))
+ }
+}
+
+// appendString writes an escaped, double-quoted string to buf
+func appendString(fmt format, s string) {
+ if !fmt.raw {
+ // Only handle quoting if NOT raw
+ if !strconv.CanBackquote(s) || !fmt.isKey {
+ // All non-keys and multiline keys get quoted + escaped
+ fmt.buf.B = strconv.AppendQuote(fmt.buf.B, s)
+ return
+ } else if containsSpaceOrTab(s) {
+ // Key containing spaces/tabs, quote this
+ fmt.buf.WriteByte('"')
+ fmt.buf.WriteString(s)
+ fmt.buf.WriteByte('"')
+ return
+ }
+ }
+
+ // Safe to leave unquoted
+ fmt.buf.WriteString(s)
+}
+
+// appendStringSlice writes a slice of strings to buf
+func appendStringSlice(fmt format, s []string) {
+ // Check for nil slice
+ if s == nil {
+ appendNilType(fmt, `[]string`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Prepare formatter
+ fmt = fmt.IsKey(false)
+
+ // Write elements
+ for _, s := range s {
+ appendString(fmt, s)
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(s) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendBool writes a formatted bool to buf
+func appendBool(fmt format, b bool) {
+ fmt.buf.B = strconv.AppendBool(fmt.buf.B, b)
+}
+
+// appendBool writes a slice of formatted bools to buf
+func appendBoolSlice(fmt format, b []bool) {
+ // Check for nil slice
+ if b == nil {
+ appendNilType(fmt, `[]bool`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Write elements
+ for _, b := range b {
+ appendBool(fmt, b)
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(b) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendInt writes a formatted int to buf
+func appendInt(fmt format, i int64) {
+ fmt.buf.B = strconv.AppendInt(fmt.buf.B, i, 10)
+}
+
+// appendIntSlice writes a slice of formatted int to buf
+func appendIntSlice(fmt format, i []int) {
+ // Check for nil slice
+ if i == nil {
+ appendNilType(fmt, `[]int`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Write elements
+ for _, i := range i {
+ appendInt(fmt, int64(i))
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(i) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendUint writes a formatted uint to buf
+func appendUint(fmt format, u uint64) {
+ fmt.buf.B = strconv.AppendUint(fmt.buf.B, u, 10)
+}
+
+// appendUintSlice writes a slice of formatted uint to buf
+func appendUintSlice(fmt format, u []uint) {
+ // Check for nil slice
+ if u == nil {
+ appendNilType(fmt, `[]uint`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Write elements
+ for _, u := range u {
+ appendUint(fmt, uint64(u))
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(u) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendFloat writes a formatted float to buf
+func appendFloat(fmt format, f float64) {
+ fmt.buf.B = strconv.AppendFloat(fmt.buf.B, f, 'G', -1, 64)
+}
+
+// appendFloatSlice writes a slice formatted floats to buf
+func appendFloatSlice(fmt format, f []float64) {
+ // Check for nil slice
+ if f == nil {
+ appendNilType(fmt, `[]float64`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Write elements
+ for _, f := range f {
+ appendFloat(fmt, f)
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(f) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendTime writes a formatted, quoted time string to buf
+func appendTime(fmt format, t time.Time) {
+ appendString(fmt.IsKey(true), t.Format(fmt.txt.TimeFormat))
+}
+
+// appendTimeSlice writes a slice of formatted time strings to buf
+func appendTimeSlice(fmt format, t []time.Time) {
+ // Check for nil slice
+ if t == nil {
+ appendNilType(fmt, `[]time.Time`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Prepare formatter
+ fmt = fmt.IsKey(true)
+
+ // Write elements
+ for _, t := range t {
+ appendString(fmt, t.Format(fmt.txt.TimeFormat))
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(t) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendDuration writes a formatted, quoted duration string to buf
+func appendDuration(fmt format, d time.Duration) {
+ appendString(fmt.IsKey(true), d.String())
+}
+
+// appendDurationSlice writes a slice of formatted, quoted duration strings to buf
+func appendDurationSlice(fmt format, d []time.Duration) {
+ // Check for nil slice
+ if d == nil {
+ appendNilType(fmt, `[]time.Duration`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Prepare formatter
+ fmt = fmt.IsKey(true)
+
+ // Write elements
+ for _, d := range d {
+ appendString(fmt, d.String())
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(d) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendComplex writes a formatted complex128 to buf
+func appendComplex(fmt format, c complex128) {
+ appendFloat(fmt, real(c))
+ fmt.buf.WriteByte('+')
+ appendFloat(fmt, imag(c))
+ fmt.buf.WriteByte('i')
+}
+
+// appendComplexSlice writes a slice of formatted complex128s to buf
+func appendComplexSlice(fmt format, c []complex128) {
+ // Check for nil slice
+ if c == nil {
+ appendNilType(fmt, `[]complex128`)
+ return
+ }
+
+ fmt.buf.WriteByte('[')
+
+ // Write elements
+ for _, c := range c {
+ appendComplex(fmt, c)
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if len(c) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// notNil will safely check if 'v' is nil without dealing with weird Go interface nil bullshit.
+func notNil(i interface{}) bool {
+ // cast to get fat pointer
+ e := *(*struct {
+ typeOf unsafe.Pointer // ignored
+ valueOf unsafe.Pointer
+ })(unsafe.Pointer(&i))
+
+ // check if value part is nil
+ return (e.valueOf != nil)
+}
+
+// appendNilType will append a formatted nil of type 't'
+func appendNilType(fmt format, t string) {
+ fmt.buf.WriteByte('(')
+ fmt.buf.WriteString(t)
+ fmt.buf.WriteString(`)(<nil>)`)
+}
+
+// appendNilValue will append a formatted nil of type fetched from value 'v'
+func appendNilRValue(fmt format, v reflect.Value) {
+ appendNilType(fmt, v.Type().String())
+}
+
+// appendIfaceOrReflectValue will attempt to append as interface, falling back to reflection
+func appendIfaceOrRValue(fmt format, i interface{}) {
+ // Check we haven't hit max
+ if fmt.depth >= fmt.txt.MaxDepth {
+ fmt.buf.WriteString("...")
+ return
+ }
+
+ // Incr the depth
+ fmt = fmt.IncrDepth()
+
+ // Attempt to append interface, fallback to reflect
+ if !appendIface(fmt, i) {
+ appendRValue(fmt, reflect.ValueOf(i))
+ }
+}
+
+// appendReflectValueOrIface will attempt to interface the reflect.Value, falling back to using this directly
+func appendRValueOrIface(fmt format, v reflect.Value) {
+ // Check we haven't hit max
+ if fmt.depth >= fmt.txt.MaxDepth {
+ fmt.buf.WriteString("...")
+ return
+ }
+
+ // Incr the depth
+ fmt = fmt.IncrDepth()
+
+ // Attempt to interface reflect value, fallback to handling value itself
+ if !v.CanInterface() || !appendIface(fmt, v.Interface()) {
+ appendRValue(fmt, v)
+ }
+}
+
+// appendIface parses and writes a formatted interface value to buf
+func appendIface(fmt format, i interface{}) bool {
+ switch i := i.(type) {
+ case nil:
+ fmt.buf.WriteString(`<nil>`)
+ case byte:
+ appendByte(fmt, i)
+ case []byte:
+ appendBytes(fmt, i)
+ case string:
+ appendString(fmt, i)
+ case []string:
+ appendStringSlice(fmt, i)
+ case int:
+ appendInt(fmt, int64(i))
+ case int8:
+ appendInt(fmt, int64(i))
+ case int16:
+ appendInt(fmt, int64(i))
+ case int32:
+ appendInt(fmt, int64(i))
+ case int64:
+ appendInt(fmt, i)
+ case []int:
+ appendIntSlice(fmt, i)
+ case uint:
+ appendUint(fmt, uint64(i))
+ case uint16:
+ appendUint(fmt, uint64(i))
+ case uint32:
+ appendUint(fmt, uint64(i))
+ case uint64:
+ appendUint(fmt, i)
+ case []uint:
+ appendUintSlice(fmt, i)
+ case float32:
+ appendFloat(fmt, float64(i))
+ case float64:
+ appendFloat(fmt, i)
+ case []float64:
+ appendFloatSlice(fmt, i)
+ case bool:
+ appendBool(fmt, i)
+ case []bool:
+ appendBoolSlice(fmt, i)
+ case time.Time:
+ appendTime(fmt, i)
+ case []time.Time:
+ appendTimeSlice(fmt, i)
+ case time.Duration:
+ appendDuration(fmt, i)
+ case []time.Duration:
+ appendDurationSlice(fmt, i)
+ case complex64:
+ appendComplex(fmt, complex128(i))
+ case complex128:
+ appendComplex(fmt, i)
+ case []complex128:
+ appendComplexSlice(fmt, i)
+ case map[string]interface{}:
+ appendIfaceMap(fmt, i)
+ case error:
+ if notNil(i) /* use safer nil check */ {
+ appendString(fmt, i.Error())
+ } else {
+ appendNilType(fmt, reflect.TypeOf(i).String())
+ }
+ case stdfmt.Stringer:
+ if notNil(i) /* use safer nil check */ {
+ appendString(fmt, i.String())
+ } else {
+ appendNilType(fmt, reflect.TypeOf(i).String())
+ }
+ default:
+ return false // could not handle
+ }
+
+ return true
+}
+
+// appendReflectValue will safely append a reflected value
+func appendRValue(fmt format, v reflect.Value) {
+ switch v.Kind() {
+ case reflect.Float32, reflect.Float64:
+ appendFloat(fmt, v.Float())
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ appendInt(fmt, v.Int())
+ case reflect.Uint8:
+ appendByte(fmt, uint8(v.Uint()))
+ case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ appendUint(fmt, v.Uint())
+ case reflect.Bool:
+ appendBool(fmt, v.Bool())
+ case reflect.Array:
+ appendArrayType(fmt, v)
+ case reflect.Slice:
+ appendSliceType(fmt, v)
+ case reflect.Map:
+ appendMapType(fmt, v)
+ case reflect.Struct:
+ appendStructType(fmt, v)
+ case reflect.Ptr:
+ if v.IsNil() {
+ appendNilRValue(fmt, v)
+ } else {
+ appendRValue(fmt, v.Elem())
+ }
+ case reflect.UnsafePointer:
+ fmt.buf.WriteString("(unsafe.Pointer)")
+ fmt.buf.WriteByte('(')
+ if u := v.Pointer(); u != 0 {
+ fmt.buf.WriteString("0x")
+ fmt.buf.B = strconv.AppendUint(fmt.buf.B, uint64(u), 16)
+ } else {
+ fmt.buf.WriteString(`<nil>`)
+ }
+ fmt.buf.WriteByte(')')
+ case reflect.Uintptr:
+ fmt.buf.WriteString("(uintptr)")
+ fmt.buf.WriteByte('(')
+ if u := v.Uint(); u != 0 {
+ fmt.buf.WriteString("0x")
+ fmt.buf.B = strconv.AppendUint(fmt.buf.B, u, 16)
+ } else {
+ fmt.buf.WriteString(`<nil>`)
+ }
+ fmt.buf.WriteByte(')')
+ case reflect.String:
+ appendString(fmt, v.String())
+ case reflect.Complex64, reflect.Complex128:
+ appendComplex(fmt, v.Complex())
+ case reflect.Func, reflect.Chan, reflect.Interface:
+ if v.IsNil() {
+ appendNilRValue(fmt, v)
+ } else {
+ fmt.buf.WriteString(v.String())
+ }
+ default:
+ fmt.buf.WriteString(v.String())
+ }
+}
+
+// appendIfaceMap writes a map of key-value pairs (as a set of fields) to buf
+func appendIfaceMap(fmt format, v map[string]interface{}) {
+ // Catch nil map
+ if v == nil {
+ appendNilType(fmt, `map[string]interface{}`)
+ return
+ }
+
+ fmt.buf.WriteByte('{')
+
+ // Prepare formatters
+ fmtKey := fmt.IsKey(true)
+ fmtVal := fmt.IsKey(false)
+
+ // Write map pairs!
+ for key, value := range v {
+ appendString(fmtKey, key)
+ fmt.buf.WriteByte('=')
+ appendIfaceOrRValue(fmtVal, value)
+ fmt.buf.WriteByte(' ')
+ }
+
+ // Drop last space
+ if len(v) > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte('}')
+}
+
+// appendArrayType writes an array of unknown type (parsed by reflection) to buf, unlike appendSliceType does NOT catch nil slice
+func appendArrayType(fmt format, v reflect.Value) {
+ // get no. elements
+ n := v.Len()
+
+ fmt.buf.WriteByte('[')
+
+ // Prepare formatter
+ fmt = fmt.IsKey(false)
+
+ // Write values
+ for i := 0; i < n; i++ {
+ appendRValueOrIface(fmt, v.Index(i))
+ fmt.buf.WriteByte(',')
+ }
+
+ // Drop last comma
+ if n > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte(']')
+}
+
+// appendSliceType writes a slice of unknown type (parsed by reflection) to buf
+func appendSliceType(fmt format, v reflect.Value) {
+ if v.IsNil() {
+ appendNilRValue(fmt, v)
+ } else {
+ appendArrayType(fmt, v)
+ }
+}
+
+// appendMapType writes a map of unknown types (parsed by reflection) to buf
+func appendMapType(fmt format, v reflect.Value) {
+ // Catch nil map
+ if v.IsNil() {
+ appendNilRValue(fmt, v)
+ return
+ }
+
+ // Get a map iterator
+ r := v.MapRange()
+ n := v.Len()
+
+ fmt.buf.WriteByte('{')
+
+ // Prepare formatters
+ fmtKey := fmt.IsKey(true)
+ fmtVal := fmt.IsKey(false)
+
+ // Iterate pairs
+ for r.Next() {
+ appendRValueOrIface(fmtKey, r.Key())
+ fmt.buf.WriteByte('=')
+ appendRValueOrIface(fmtVal, r.Value())
+ fmt.buf.WriteByte(' ')
+ }
+
+ // Drop last space
+ if n > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte('}')
+}
+
+// appendStructType writes a struct (as a set of key-value fields) to buf
+func appendStructType(fmt format, v reflect.Value) {
+ // Get value type & no. fields
+ t := v.Type()
+ n := v.NumField()
+ w := 0
+
+ fmt.buf.WriteByte('{')
+
+ // Prepare formatters
+ fmtKey := fmt.IsKey(true)
+ fmtVal := fmt.IsKey(false)
+
+ // Iterate fields
+ for i := 0; i < n; i++ {
+ vfield := v.Field(i)
+
+ if !vfield.CanInterface() {
+ // This is an unexported field
+ appendRValue(fmtVal, vfield)
+ } else {
+ // This is an exported field!
+ appendString(fmtKey, t.Field(i).Name)
+ fmt.buf.WriteByte('=')
+ appendRValueOrIface(fmtVal, vfield)
+ }
+
+ // Iter written count
+ fmt.buf.WriteByte(' ')
+ w++
+ }
+
+ // Drop last space
+ if w > 0 {
+ fmt.buf.Truncate(1)
+ }
+
+ fmt.buf.WriteByte('}')
+}
+
+// appendKey should only be used in the case of directly setting key-value pairs,
+// not in the case of appendMapType, appendStructType
+func appendKey(buf *bytes.Buffer, key string) {
+ if len(key) > 0 {
+ if containsSpaceOrTab(key) {
+ // Key containing spaces/tabs, quote this
+ buf.WriteByte('"')
+ buf.WriteString(key)
+ buf.WriteByte('"')
+ } else {
+ // Key is safe to leave unquoted
+ buf.WriteString(key)
+ }
+
+ // Write final '='
+ buf.WriteByte('=')
+ }
+}
+
+// containsSpaceOrTab checks if "s" contains space or tabs
+func containsSpaceOrTab(s string) bool {
+ for _, r := range s {
+ if r == ' ' || r == '\t' {
+ return true
+ }
+ }
+ return false
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 05:19:41 +0000