cmd/bpa-operator/vendor/github.com/json-iterator/go/any_array.go

   1 package jsoniter
   2
   3 import (
   4         "reflect"
   5         "unsafe"
   6 )
   7
   8 type arrayLazyAny struct {
   9         baseAny
  10         cfg *frozenConfig
  11         buf []byte
  12         err error
  13 }
  14
  15 func (any *arrayLazyAny) ValueType() ValueType {
  16         return ArrayValue
  17 }
  18
  19 func (any *arrayLazyAny) MustBeValid() Any {
  20         return any
  21 }
  22
  23 func (any *arrayLazyAny) LastError() error {
  24         return any.err
  25 }
  26
  27 func (any *arrayLazyAny) ToBool() bool {
  28         iter := any.cfg.BorrowIterator(any.buf)
  29         defer any.cfg.ReturnIterator(iter)
  30         return iter.ReadArray()
  31 }
  32
  33 func (any *arrayLazyAny) ToInt() int {
  34         if any.ToBool() {
  35                 return 1
  36         }
  37         return 0
  38 }
  39
  40 func (any *arrayLazyAny) ToInt32() int32 {
  41         if any.ToBool() {
  42                 return 1
  43         }
  44         return 0
  45 }
  46
  47 func (any *arrayLazyAny) ToInt64() int64 {
  48         if any.ToBool() {
  49                 return 1
  50         }
  51         return 0
  52 }
  53
  54 func (any *arrayLazyAny) ToUint() uint {
  55         if any.ToBool() {
  56                 return 1
  57         }
  58         return 0
  59 }
  60
  61 func (any *arrayLazyAny) ToUint32() uint32 {
  62         if any.ToBool() {
  63                 return 1
  64         }
  65         return 0
  66 }
  67
  68 func (any *arrayLazyAny) ToUint64() uint64 {
  69         if any.ToBool() {
  70                 return 1
  71         }
  72         return 0
  73 }
  74
  75 func (any *arrayLazyAny) ToFloat32() float32 {
  76         if any.ToBool() {
  77                 return 1
  78         }
  79         return 0
  80 }
  81
  82 func (any *arrayLazyAny) ToFloat64() float64 {
  83         if any.ToBool() {
  84                 return 1
  85         }
  86         return 0
  87 }
  88
  89 func (any *arrayLazyAny) ToString() string {
  90         return *(*string)(unsafe.Pointer(&any.buf))
  91 }
  92
  93 func (any *arrayLazyAny) ToVal(val interface{}) {
  94         iter := any.cfg.BorrowIterator(any.buf)
  95         defer any.cfg.ReturnIterator(iter)
  96         iter.ReadVal(val)
  97 }
  98
  99 func (any *arrayLazyAny) Get(path ...interface{}) Any {
 100         if len(path) == 0 {
 101                 return any
 102         }
 103         switch firstPath := path[0].(type) {
 104         case int:
 105                 iter := any.cfg.BorrowIterator(any.buf)
 106                 defer any.cfg.ReturnIterator(iter)
 107                 valueBytes := locateArrayElement(iter, firstPath)
 108                 if valueBytes == nil {
 109                         return newInvalidAny(path)
 110                 }
 111                 iter.ResetBytes(valueBytes)
 112                 return locatePath(iter, path[1:])
 113         case int32:
 114                 if '*' == firstPath {
 115                         iter := any.cfg.BorrowIterator(any.buf)
 116                         defer any.cfg.ReturnIterator(iter)
 117                         arr := make([]Any, 0)
 118                         iter.ReadArrayCB(func(iter *Iterator) bool {
 119                                 found := iter.readAny().Get(path[1:]...)
 120                                 if found.ValueType() != InvalidValue {
 121                                         arr = append(arr, found)
 122                                 }
 123                                 return true
 124                         })
 125                         return wrapArray(arr)
 126                 }
 127                 return newInvalidAny(path)
 128         default:
 129                 return newInvalidAny(path)
 130         }
 131 }
 132
 133 func (any *arrayLazyAny) Size() int {
 134         size := 0
 135         iter := any.cfg.BorrowIterator(any.buf)
 136         defer any.cfg.ReturnIterator(iter)
 137         iter.ReadArrayCB(func(iter *Iterator) bool {
 138                 size++
 139                 iter.Skip()
 140                 return true
 141         })
 142         return size
 143 }
 144
 145 func (any *arrayLazyAny) WriteTo(stream *Stream) {
 146         stream.Write(any.buf)
 147 }
 148
 149 func (any *arrayLazyAny) GetInterface() interface{} {
 150         iter := any.cfg.BorrowIterator(any.buf)
 151         defer any.cfg.ReturnIterator(iter)
 152         return iter.Read()
 153 }
 154
 155 type arrayAny struct {
 156         baseAny
 157         val reflect.Value
 158 }
 159
 160 func wrapArray(val interface{}) *arrayAny {
 161         return &arrayAny{baseAny{}, reflect.ValueOf(val)}
 162 }
 163
 164 func (any *arrayAny) ValueType() ValueType {
 165         return ArrayValue
 166 }
 167
 168 func (any *arrayAny) MustBeValid() Any {
 169         return any
 170 }
 171
 172 func (any *arrayAny) LastError() error {
 173         return nil
 174 }
 175
 176 func (any *arrayAny) ToBool() bool {
 177         return any.val.Len() != 0
 178 }
 179
 180 func (any *arrayAny) ToInt() int {
 181         if any.val.Len() == 0 {
 182                 return 0
 183         }
 184         return 1
 185 }
 186
 187 func (any *arrayAny) ToInt32() int32 {
 188         if any.val.Len() == 0 {
 189                 return 0
 190         }
 191         return 1
 192 }
 193
 194 func (any *arrayAny) ToInt64() int64 {
 195         if any.val.Len() == 0 {
 196                 return 0
 197         }
 198         return 1
 199 }
 200
 201 func (any *arrayAny) ToUint() uint {
 202         if any.val.Len() == 0 {
 203                 return 0
 204         }
 205         return 1
 206 }
 207
 208 func (any *arrayAny) ToUint32() uint32 {
 209         if any.val.Len() == 0 {
 210                 return 0
 211         }
 212         return 1
 213 }
 214
 215 func (any *arrayAny) ToUint64() uint64 {
 216         if any.val.Len() == 0 {
 217                 return 0
 218         }
 219         return 1
 220 }
 221
 222 func (any *arrayAny) ToFloat32() float32 {
 223         if any.val.Len() == 0 {
 224                 return 0
 225         }
 226         return 1
 227 }
 228
 229 func (any *arrayAny) ToFloat64() float64 {
 230         if any.val.Len() == 0 {
 231                 return 0
 232         }
 233         return 1
 234 }
 235
 236 func (any *arrayAny) ToString() string {
 237         str, _ := MarshalToString(any.val.Interface())
 238         return str
 239 }
 240
 241 func (any *arrayAny) Get(path ...interface{}) Any {
 242         if len(path) == 0 {
 243                 return any
 244         }
 245         switch firstPath := path[0].(type) {
 246         case int:
 247                 if firstPath < 0 || firstPath >= any.val.Len() {
 248                         return newInvalidAny(path)
 249                 }
 250                 return Wrap(any.val.Index(firstPath).Interface())
 251         case int32:
 252                 if '*' == firstPath {
 253                         mappedAll := make([]Any, 0)
 254                         for i := 0; i < any.val.Len(); i++ {
 255                                 mapped := Wrap(any.val.Index(i).Interface()).Get(path[1:]...)
 256                                 if mapped.ValueType() != InvalidValue {
 257                                         mappedAll = append(mappedAll, mapped)
 258                                 }
 259                         }
 260                         return wrapArray(mappedAll)
 261                 }
 262                 return newInvalidAny(path)
 263         default:
 264                 return newInvalidAny(path)
 265         }
 266 }
 267
 268 func (any *arrayAny) Size() int {
 269         return any.val.Len()
 270 }
 271
 272 func (any *arrayAny) WriteTo(stream *Stream) {
 273         stream.WriteVal(any.val)
 274 }
 275
 276 func (any *arrayAny) GetInterface() interface{} {
 277         return any.val.Interface()
 278 }