"Fossies" - the Fresh Open Source Software Archive

Member "buildah-1.23.1/vendor/github.com/json-iterator/go/any_array.go" (28 Sep 2021, 4838 Bytes) of package /linux/misc/buildah-1.23.1.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    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 }