1 files changed, 374 insertions, 0 deletions

diff --git a/vendor/github.com/json-iterator/go/any_object.go b/vendor/github.com/json-iterator/go/any_object.go
new file mode 100644
index 0000000..c44ef5c
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_object.go
@@ -0,0 +1,374 @@
+package jsoniter
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type objectLazyAny struct {
+        baseAny
+        cfg *frozenConfig
+        buf []byte
+        err error
+}
+
+func (any *objectLazyAny) ValueType() ValueType {
+        return ObjectValue
+}
+
+func (any *objectLazyAny) MustBeValid() Any {
+        return any
+}
+
+func (any *objectLazyAny) LastError() error {
+        return any.err
+}
+
+func (any *objectLazyAny) ToBool() bool {
+        return true
+}
+
+func (any *objectLazyAny) ToInt() int {
+        return 0
+}
+
+func (any *objectLazyAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *objectLazyAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *objectLazyAny) ToUint() uint {
+        return 0
+}
+
+func (any *objectLazyAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *objectLazyAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *objectLazyAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *objectLazyAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *objectLazyAny) ToString() string {
+        return *(*string)(unsafe.Pointer(&any.buf))
+}
+
+func (any *objectLazyAny) ToVal(obj interface{}) {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadVal(obj)
+}
+
+func (any *objectLazyAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case string:
+                iter := any.cfg.BorrowIterator(any.buf)
+                defer any.cfg.ReturnIterator(iter)
+                valueBytes := locateObjectField(iter, firstPath)
+                if valueBytes == nil {
+                        return newInvalidAny(path)
+                }
+                iter.ResetBytes(valueBytes)
+                return locatePath(iter, path[1:])
+        case int32:
+                if '*' == firstPath {
+                        mappedAll := map[string]Any{}
+                        iter := any.cfg.BorrowIterator(any.buf)
+                        defer any.cfg.ReturnIterator(iter)
+                        iter.ReadMapCB(func(iter *Iterator, field string) bool {
+                                mapped := locatePath(iter, path[1:])
+                                if mapped.ValueType() != InvalidValue {
+                                        mappedAll[field] = mapped
+                                }
+                                return true
+                        })
+                        return wrapMap(mappedAll)
+                }
+                return newInvalidAny(path)
+        default:
+                return newInvalidAny(path)
+        }
+}
+
+func (any *objectLazyAny) Keys() []string {
+        keys := []string{}
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadMapCB(func(iter *Iterator, field string) bool {
+                iter.Skip()
+                keys = append(keys, field)
+                return true
+        })
+        return keys
+}
+
+func (any *objectLazyAny) Size() int {
+        size := 0
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadObjectCB(func(iter *Iterator, field string) bool {
+                iter.Skip()
+                size++
+                return true
+        })
+        return size
+}
+
+func (any *objectLazyAny) WriteTo(stream *Stream) {
+        stream.Write(any.buf)
+}
+
+func (any *objectLazyAny) GetInterface() interface{} {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        return iter.Read()
+}
+
+type objectAny struct {
+        baseAny
+        err error
+        val reflect.Value
+}
+
+func wrapStruct(val interface{}) *objectAny {
+        return &objectAny{baseAny{}, nil, reflect.ValueOf(val)}
+}
+
+func (any *objectAny) ValueType() ValueType {
+        return ObjectValue
+}
+
+func (any *objectAny) MustBeValid() Any {
+        return any
+}
+
+func (any *objectAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *objectAny) LastError() error {
+        return any.err
+}
+
+func (any *objectAny) ToBool() bool {
+        return any.val.NumField() != 0
+}
+
+func (any *objectAny) ToInt() int {
+        return 0
+}
+
+func (any *objectAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *objectAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *objectAny) ToUint() uint {
+        return 0
+}
+
+func (any *objectAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *objectAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *objectAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *objectAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *objectAny) ToString() string {
+        str, err := MarshalToString(any.val.Interface())
+        any.err = err
+        return str
+}
+
+func (any *objectAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case string:
+                field := any.val.FieldByName(firstPath)
+                if !field.IsValid() {
+                        return newInvalidAny(path)
+                }
+                return Wrap(field.Interface())
+        case int32:
+                if '*' == firstPath {
+                        mappedAll := map[string]Any{}
+                        for i := 0; i < any.val.NumField(); i++ {
+                                field := any.val.Field(i)
+                                if field.CanInterface() {
+                                        mapped := Wrap(field.Interface()).Get(path[1:]...)
+                                        if mapped.ValueType() != InvalidValue {
+                                                mappedAll[any.val.Type().Field(i).Name] = mapped
+                                        }
+                                }
+                        }
+                        return wrapMap(mappedAll)
+                }
+                return newInvalidAny(path)
+        default:
+                return newInvalidAny(path)
+        }
+}
+
+func (any *objectAny) Keys() []string {
+        keys := make([]string, 0, any.val.NumField())
+        for i := 0; i < any.val.NumField(); i++ {
+                keys = append(keys, any.val.Type().Field(i).Name)
+        }
+        return keys
+}
+
+func (any *objectAny) Size() int {
+        return any.val.NumField()
+}
+
+func (any *objectAny) WriteTo(stream *Stream) {
+        stream.WriteVal(any.val)
+}
+
+func (any *objectAny) GetInterface() interface{} {
+        return any.val.Interface()
+}
+
+type mapAny struct {
+        baseAny
+        err error
+        val reflect.Value
+}
+
+func wrapMap(val interface{}) *mapAny {
+        return &mapAny{baseAny{}, nil, reflect.ValueOf(val)}
+}
+
+func (any *mapAny) ValueType() ValueType {
+        return ObjectValue
+}
+
+func (any *mapAny) MustBeValid() Any {
+        return any
+}
+
+func (any *mapAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *mapAny) LastError() error {
+        return any.err
+}
+
+func (any *mapAny) ToBool() bool {
+        return true
+}
+
+func (any *mapAny) ToInt() int {
+        return 0
+}
+
+func (any *mapAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *mapAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *mapAny) ToUint() uint {
+        return 0
+}
+
+func (any *mapAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *mapAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *mapAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *mapAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *mapAny) ToString() string {
+        str, err := MarshalToString(any.val.Interface())
+        any.err = err
+        return str
+}
+
+func (any *mapAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case int32:
+                if '*' == firstPath {
+                        mappedAll := map[string]Any{}
+                        for _, key := range any.val.MapKeys() {
+                                keyAsStr := key.String()
+                                element := Wrap(any.val.MapIndex(key).Interface())
+                                mapped := element.Get(path[1:]...)
+                                if mapped.ValueType() != InvalidValue {
+                                        mappedAll[keyAsStr] = mapped
+                                }
+                        }
+                        return wrapMap(mappedAll)
+                }
+                return newInvalidAny(path)
+        default:
+                value := any.val.MapIndex(reflect.ValueOf(firstPath))
+                if !value.IsValid() {
+                        return newInvalidAny(path)
+                }
+                return Wrap(value.Interface())
+        }
+}
+
+func (any *mapAny) Keys() []string {
+        keys := make([]string, 0, any.val.Len())
+        for _, key := range any.val.MapKeys() {
+                keys = append(keys, key.String())
+        }
+        return keys
+}
+
+func (any *mapAny) Size() int {
+        return any.val.Len()
+}
+
+func (any *mapAny) WriteTo(stream *Stream) {
+        stream.WriteVal(any.val)
+}
+
+func (any *mapAny) GetInterface() interface{} {
+        return any.val.Interface()
+}