gtsocial-umbx

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE

any_object.go (6937B)

      1 package jsoniter
      2 
      3 import (
      4 	"reflect"
      5 	"unsafe"
      6 )
      7 
      8 type objectLazyAny struct {
      9 	baseAny
     10 	cfg *frozenConfig
     11 	buf []byte
     12 	err error
     13 }
     14 
     15 func (any *objectLazyAny) ValueType() ValueType {
     16 	return ObjectValue
     17 }
     18 
     19 func (any *objectLazyAny) MustBeValid() Any {
     20 	return any
     21 }
     22 
     23 func (any *objectLazyAny) LastError() error {
     24 	return any.err
     25 }
     26 
     27 func (any *objectLazyAny) ToBool() bool {
     28 	return true
     29 }
     30 
     31 func (any *objectLazyAny) ToInt() int {
     32 	return 0
     33 }
     34 
     35 func (any *objectLazyAny) ToInt32() int32 {
     36 	return 0
     37 }
     38 
     39 func (any *objectLazyAny) ToInt64() int64 {
     40 	return 0
     41 }
     42 
     43 func (any *objectLazyAny) ToUint() uint {
     44 	return 0
     45 }
     46 
     47 func (any *objectLazyAny) ToUint32() uint32 {
     48 	return 0
     49 }
     50 
     51 func (any *objectLazyAny) ToUint64() uint64 {
     52 	return 0
     53 }
     54 
     55 func (any *objectLazyAny) ToFloat32() float32 {
     56 	return 0
     57 }
     58 
     59 func (any *objectLazyAny) ToFloat64() float64 {
     60 	return 0
     61 }
     62 
     63 func (any *objectLazyAny) ToString() string {
     64 	return *(*string)(unsafe.Pointer(&any.buf))
     65 }
     66 
     67 func (any *objectLazyAny) ToVal(obj interface{}) {
     68 	iter := any.cfg.BorrowIterator(any.buf)
     69 	defer any.cfg.ReturnIterator(iter)
     70 	iter.ReadVal(obj)
     71 }
     72 
     73 func (any *objectLazyAny) Get(path ...interface{}) Any {
     74 	if len(path) == 0 {
     75 		return any
     76 	}
     77 	switch firstPath := path[0].(type) {
     78 	case string:
     79 		iter := any.cfg.BorrowIterator(any.buf)
     80 		defer any.cfg.ReturnIterator(iter)
     81 		valueBytes := locateObjectField(iter, firstPath)
     82 		if valueBytes == nil {
     83 			return newInvalidAny(path)
     84 		}
     85 		iter.ResetBytes(valueBytes)
     86 		return locatePath(iter, path[1:])
     87 	case int32:
     88 		if '*' == firstPath {
     89 			mappedAll := map[string]Any{}
     90 			iter := any.cfg.BorrowIterator(any.buf)
     91 			defer any.cfg.ReturnIterator(iter)
     92 			iter.ReadMapCB(func(iter *Iterator, field string) bool {
     93 				mapped := locatePath(iter, path[1:])
     94 				if mapped.ValueType() != InvalidValue {
     95 					mappedAll[field] = mapped
     96 				}
     97 				return true
     98 			})
     99 			return wrapMap(mappedAll)
    100 		}
    101 		return newInvalidAny(path)
    102 	default:
    103 		return newInvalidAny(path)
    104 	}
    105 }
    106 
    107 func (any *objectLazyAny) Keys() []string {
    108 	keys := []string{}
    109 	iter := any.cfg.BorrowIterator(any.buf)
    110 	defer any.cfg.ReturnIterator(iter)
    111 	iter.ReadMapCB(func(iter *Iterator, field string) bool {
    112 		iter.Skip()
    113 		keys = append(keys, field)
    114 		return true
    115 	})
    116 	return keys
    117 }
    118 
    119 func (any *objectLazyAny) Size() int {
    120 	size := 0
    121 	iter := any.cfg.BorrowIterator(any.buf)
    122 	defer any.cfg.ReturnIterator(iter)
    123 	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
    124 		iter.Skip()
    125 		size++
    126 		return true
    127 	})
    128 	return size
    129 }
    130 
    131 func (any *objectLazyAny) WriteTo(stream *Stream) {
    132 	stream.Write(any.buf)
    133 }
    134 
    135 func (any *objectLazyAny) GetInterface() interface{} {
    136 	iter := any.cfg.BorrowIterator(any.buf)
    137 	defer any.cfg.ReturnIterator(iter)
    138 	return iter.Read()
    139 }
    140 
    141 type objectAny struct {
    142 	baseAny
    143 	err error
    144 	val reflect.Value
    145 }
    146 
    147 func wrapStruct(val interface{}) *objectAny {
    148 	return &objectAny{baseAny{}, nil, reflect.ValueOf(val)}
    149 }
    150 
    151 func (any *objectAny) ValueType() ValueType {
    152 	return ObjectValue
    153 }
    154 
    155 func (any *objectAny) MustBeValid() Any {
    156 	return any
    157 }
    158 
    159 func (any *objectAny) Parse() *Iterator {
    160 	return nil
    161 }
    162 
    163 func (any *objectAny) LastError() error {
    164 	return any.err
    165 }
    166 
    167 func (any *objectAny) ToBool() bool {
    168 	return any.val.NumField() != 0
    169 }
    170 
    171 func (any *objectAny) ToInt() int {
    172 	return 0
    173 }
    174 
    175 func (any *objectAny) ToInt32() int32 {
    176 	return 0
    177 }
    178 
    179 func (any *objectAny) ToInt64() int64 {
    180 	return 0
    181 }
    182 
    183 func (any *objectAny) ToUint() uint {
    184 	return 0
    185 }
    186 
    187 func (any *objectAny) ToUint32() uint32 {
    188 	return 0
    189 }
    190 
    191 func (any *objectAny) ToUint64() uint64 {
    192 	return 0
    193 }
    194 
    195 func (any *objectAny) ToFloat32() float32 {
    196 	return 0
    197 }
    198 
    199 func (any *objectAny) ToFloat64() float64 {
    200 	return 0
    201 }
    202 
    203 func (any *objectAny) ToString() string {
    204 	str, err := MarshalToString(any.val.Interface())
    205 	any.err = err
    206 	return str
    207 }
    208 
    209 func (any *objectAny) Get(path ...interface{}) Any {
    210 	if len(path) == 0 {
    211 		return any
    212 	}
    213 	switch firstPath := path[0].(type) {
    214 	case string:
    215 		field := any.val.FieldByName(firstPath)
    216 		if !field.IsValid() {
    217 			return newInvalidAny(path)
    218 		}
    219 		return Wrap(field.Interface())
    220 	case int32:
    221 		if '*' == firstPath {
    222 			mappedAll := map[string]Any{}
    223 			for i := 0; i < any.val.NumField(); i++ {
    224 				field := any.val.Field(i)
    225 				if field.CanInterface() {
    226 					mapped := Wrap(field.Interface()).Get(path[1:]...)
    227 					if mapped.ValueType() != InvalidValue {
    228 						mappedAll[any.val.Type().Field(i).Name] = mapped
    229 					}
    230 				}
    231 			}
    232 			return wrapMap(mappedAll)
    233 		}
    234 		return newInvalidAny(path)
    235 	default:
    236 		return newInvalidAny(path)
    237 	}
    238 }
    239 
    240 func (any *objectAny) Keys() []string {
    241 	keys := make([]string, 0, any.val.NumField())
    242 	for i := 0; i < any.val.NumField(); i++ {
    243 		keys = append(keys, any.val.Type().Field(i).Name)
    244 	}
    245 	return keys
    246 }
    247 
    248 func (any *objectAny) Size() int {
    249 	return any.val.NumField()
    250 }
    251 
    252 func (any *objectAny) WriteTo(stream *Stream) {
    253 	stream.WriteVal(any.val)
    254 }
    255 
    256 func (any *objectAny) GetInterface() interface{} {
    257 	return any.val.Interface()
    258 }
    259 
    260 type mapAny struct {
    261 	baseAny
    262 	err error
    263 	val reflect.Value
    264 }
    265 
    266 func wrapMap(val interface{}) *mapAny {
    267 	return &mapAny{baseAny{}, nil, reflect.ValueOf(val)}
    268 }
    269 
    270 func (any *mapAny) ValueType() ValueType {
    271 	return ObjectValue
    272 }
    273 
    274 func (any *mapAny) MustBeValid() Any {
    275 	return any
    276 }
    277 
    278 func (any *mapAny) Parse() *Iterator {
    279 	return nil
    280 }
    281 
    282 func (any *mapAny) LastError() error {
    283 	return any.err
    284 }
    285 
    286 func (any *mapAny) ToBool() bool {
    287 	return true
    288 }
    289 
    290 func (any *mapAny) ToInt() int {
    291 	return 0
    292 }
    293 
    294 func (any *mapAny) ToInt32() int32 {
    295 	return 0
    296 }
    297 
    298 func (any *mapAny) ToInt64() int64 {
    299 	return 0
    300 }
    301 
    302 func (any *mapAny) ToUint() uint {
    303 	return 0
    304 }
    305 
    306 func (any *mapAny) ToUint32() uint32 {
    307 	return 0
    308 }
    309 
    310 func (any *mapAny) ToUint64() uint64 {
    311 	return 0
    312 }
    313 
    314 func (any *mapAny) ToFloat32() float32 {
    315 	return 0
    316 }
    317 
    318 func (any *mapAny) ToFloat64() float64 {
    319 	return 0
    320 }
    321 
    322 func (any *mapAny) ToString() string {
    323 	str, err := MarshalToString(any.val.Interface())
    324 	any.err = err
    325 	return str
    326 }
    327 
    328 func (any *mapAny) Get(path ...interface{}) Any {
    329 	if len(path) == 0 {
    330 		return any
    331 	}
    332 	switch firstPath := path[0].(type) {
    333 	case int32:
    334 		if '*' == firstPath {
    335 			mappedAll := map[string]Any{}
    336 			for _, key := range any.val.MapKeys() {
    337 				keyAsStr := key.String()
    338 				element := Wrap(any.val.MapIndex(key).Interface())
    339 				mapped := element.Get(path[1:]...)
    340 				if mapped.ValueType() != InvalidValue {
    341 					mappedAll[keyAsStr] = mapped
    342 				}
    343 			}
    344 			return wrapMap(mappedAll)
    345 		}
    346 		return newInvalidAny(path)
    347 	default:
    348 		value := any.val.MapIndex(reflect.ValueOf(firstPath))
    349 		if !value.IsValid() {
    350 			return newInvalidAny(path)
    351 		}
    352 		return Wrap(value.Interface())
    353 	}
    354 }
    355 
    356 func (any *mapAny) Keys() []string {
    357 	keys := make([]string, 0, any.val.Len())
    358 	for _, key := range any.val.MapKeys() {
    359 		keys = append(keys, key.String())
    360 	}
    361 	return keys
    362 }
    363 
    364 func (any *mapAny) Size() int {
    365 	return any.val.Len()
    366 }
    367 
    368 func (any *mapAny) WriteTo(stream *Stream) {
    369 	stream.WriteVal(any.val)
    370 }
    371 
    372 func (any *mapAny) GetInterface() interface{} {
    373 	return any.val.Interface()
    374 }