cmd/bpa-operator/vendor/go.uber.org/zap/zapcore/memory_encoder.go

   1 // Copyright (c) 2016 Uber Technologies, Inc.
   2 //
   3 // Permission is hereby granted, free of charge, to any person obtaining a copy
   4 // of this software and associated documentation files (the "Software"), to deal
   5 // in the Software without restriction, including without limitation the rights
   6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7 // copies of the Software, and to permit persons to whom the Software is
   8 // furnished to do so, subject to the following conditions:
   9 //
  10 // The above copyright notice and this permission notice shall be included in
  11 // all copies or substantial portions of the Software.
  12 //
  13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19 // THE SOFTWARE.
  20
  21 package zapcore
  22
  23 import "time"
  24
  25 // MapObjectEncoder is an ObjectEncoder backed by a simple
  26 // map[string]interface{}. It's not fast enough for production use, but it's
  27 // helpful in tests.
  28 type MapObjectEncoder struct {
  29         // Fields contains the entire encoded log context.
  30         Fields map[string]interface{}
  31         // cur is a pointer to the namespace we're currently writing to.
  32         cur map[string]interface{}
  33 }
  34
  35 // NewMapObjectEncoder creates a new map-backed ObjectEncoder.
  36 func NewMapObjectEncoder() *MapObjectEncoder {
  37         m := make(map[string]interface{})
  38         return &MapObjectEncoder{
  39                 Fields: m,
  40                 cur:    m,
  41         }
  42 }
  43
  44 // AddArray implements ObjectEncoder.
  45 func (m *MapObjectEncoder) AddArray(key string, v ArrayMarshaler) error {
  46         arr := &sliceArrayEncoder{elems: make([]interface{}, 0)}
  47         err := v.MarshalLogArray(arr)
  48         m.cur[key] = arr.elems
  49         return err
  50 }
  51
  52 // AddObject implements ObjectEncoder.
  53 func (m *MapObjectEncoder) AddObject(k string, v ObjectMarshaler) error {
  54         newMap := NewMapObjectEncoder()
  55         m.cur[k] = newMap.Fields
  56         return v.MarshalLogObject(newMap)
  57 }
  58
  59 // AddBinary implements ObjectEncoder.
  60 func (m *MapObjectEncoder) AddBinary(k string, v []byte) { m.cur[k] = v }
  61
  62 // AddByteString implements ObjectEncoder.
  63 func (m *MapObjectEncoder) AddByteString(k string, v []byte) { m.cur[k] = string(v) }
  64
  65 // AddBool implements ObjectEncoder.
  66 func (m *MapObjectEncoder) AddBool(k string, v bool) { m.cur[k] = v }
  67
  68 // AddDuration implements ObjectEncoder.
  69 func (m MapObjectEncoder) AddDuration(k string, v time.Duration) { m.cur[k] = v }
  70
  71 // AddComplex128 implements ObjectEncoder.
  72 func (m *MapObjectEncoder) AddComplex128(k string, v complex128) { m.cur[k] = v }
  73
  74 // AddComplex64 implements ObjectEncoder.
  75 func (m *MapObjectEncoder) AddComplex64(k string, v complex64) { m.cur[k] = v }
  76
  77 // AddFloat64 implements ObjectEncoder.
  78 func (m *MapObjectEncoder) AddFloat64(k string, v float64) { m.cur[k] = v }
  79
  80 // AddFloat32 implements ObjectEncoder.
  81 func (m *MapObjectEncoder) AddFloat32(k string, v float32) { m.cur[k] = v }
  82
  83 // AddInt implements ObjectEncoder.
  84 func (m *MapObjectEncoder) AddInt(k string, v int) { m.cur[k] = v }
  85
  86 // AddInt64 implements ObjectEncoder.
  87 func (m *MapObjectEncoder) AddInt64(k string, v int64) { m.cur[k] = v }
  88
  89 // AddInt32 implements ObjectEncoder.
  90 func (m *MapObjectEncoder) AddInt32(k string, v int32) { m.cur[k] = v }
  91
  92 // AddInt16 implements ObjectEncoder.
  93 func (m *MapObjectEncoder) AddInt16(k string, v int16) { m.cur[k] = v }
  94
  95 // AddInt8 implements ObjectEncoder.
  96 func (m *MapObjectEncoder) AddInt8(k string, v int8) { m.cur[k] = v }
  97
  98 // AddString implements ObjectEncoder.
  99 func (m *MapObjectEncoder) AddString(k string, v string) { m.cur[k] = v }
 100
 101 // AddTime implements ObjectEncoder.
 102 func (m MapObjectEncoder) AddTime(k string, v time.Time) { m.cur[k] = v }
 103
 104 // AddUint implements ObjectEncoder.
 105 func (m *MapObjectEncoder) AddUint(k string, v uint) { m.cur[k] = v }
 106
 107 // AddUint64 implements ObjectEncoder.
 108 func (m *MapObjectEncoder) AddUint64(k string, v uint64) { m.cur[k] = v }
 109
 110 // AddUint32 implements ObjectEncoder.
 111 func (m *MapObjectEncoder) AddUint32(k string, v uint32) { m.cur[k] = v }
 112
 113 // AddUint16 implements ObjectEncoder.
 114 func (m *MapObjectEncoder) AddUint16(k string, v uint16) { m.cur[k] = v }
 115
 116 // AddUint8 implements ObjectEncoder.
 117 func (m *MapObjectEncoder) AddUint8(k string, v uint8) { m.cur[k] = v }
 118
 119 // AddUintptr implements ObjectEncoder.
 120 func (m *MapObjectEncoder) AddUintptr(k string, v uintptr) { m.cur[k] = v }
 121
 122 // AddReflected implements ObjectEncoder.
 123 func (m *MapObjectEncoder) AddReflected(k string, v interface{}) error {
 124         m.cur[k] = v
 125         return nil
 126 }
 127
 128 // OpenNamespace implements ObjectEncoder.
 129 func (m *MapObjectEncoder) OpenNamespace(k string) {
 130         ns := make(map[string]interface{})
 131         m.cur[k] = ns
 132         m.cur = ns
 133 }
 134
 135 // sliceArrayEncoder is an ArrayEncoder backed by a simple []interface{}. Like
 136 // the MapObjectEncoder, it's not designed for production use.
 137 type sliceArrayEncoder struct {
 138         elems []interface{}
 139 }
 140
 141 func (s *sliceArrayEncoder) AppendArray(v ArrayMarshaler) error {
 142         enc := &sliceArrayEncoder{}
 143         err := v.MarshalLogArray(enc)
 144         s.elems = append(s.elems, enc.elems)
 145         return err
 146 }
 147
 148 func (s *sliceArrayEncoder) AppendObject(v ObjectMarshaler) error {
 149         m := NewMapObjectEncoder()
 150         err := v.MarshalLogObject(m)
 151         s.elems = append(s.elems, m.Fields)
 152         return err
 153 }
 154
 155 func (s *sliceArrayEncoder) AppendReflected(v interface{}) error {
 156         s.elems = append(s.elems, v)
 157         return nil
 158 }
 159
 160 func (s *sliceArrayEncoder) AppendBool(v bool)              { s.elems = append(s.elems, v) }
 161 func (s *sliceArrayEncoder) AppendByteString(v []byte)      { s.elems = append(s.elems, v) }
 162 func (s *sliceArrayEncoder) AppendComplex128(v complex128)  { s.elems = append(s.elems, v) }
 163 func (s *sliceArrayEncoder) AppendComplex64(v complex64)    { s.elems = append(s.elems, v) }
 164 func (s *sliceArrayEncoder) AppendDuration(v time.Duration) { s.elems = append(s.elems, v) }
 165 func (s *sliceArrayEncoder) AppendFloat64(v float64)        { s.elems = append(s.elems, v) }
 166 func (s *sliceArrayEncoder) AppendFloat32(v float32)        { s.elems = append(s.elems, v) }
 167 func (s *sliceArrayEncoder) AppendInt(v int)                { s.elems = append(s.elems, v) }
 168 func (s *sliceArrayEncoder) AppendInt64(v int64)            { s.elems = append(s.elems, v) }
 169 func (s *sliceArrayEncoder) AppendInt32(v int32)            { s.elems = append(s.elems, v) }
 170 func (s *sliceArrayEncoder) AppendInt16(v int16)            { s.elems = append(s.elems, v) }
 171 func (s *sliceArrayEncoder) AppendInt8(v int8)              { s.elems = append(s.elems, v) }
 172 func (s *sliceArrayEncoder) AppendString(v string)          { s.elems = append(s.elems, v) }
 173 func (s *sliceArrayEncoder) AppendTime(v time.Time)         { s.elems = append(s.elems, v) }
 174 func (s *sliceArrayEncoder) AppendUint(v uint)              { s.elems = append(s.elems, v) }
 175 func (s *sliceArrayEncoder) AppendUint64(v uint64)          { s.elems = append(s.elems, v) }
 176 func (s *sliceArrayEncoder) AppendUint32(v uint32)          { s.elems = append(s.elems, v) }
 177 func (s *sliceArrayEncoder) AppendUint16(v uint16)          { s.elems = append(s.elems, v) }
 178 func (s *sliceArrayEncoder) AppendUint8(v uint8)            { s.elems = append(s.elems, v) }
 179 func (s *sliceArrayEncoder) AppendUintptr(v uintptr)        { s.elems = append(s.elems, v) }