github.com/bingoohuang/gg@v0.0.0-20240325092523-45da7dee9335/pkg/jsoni/any_object.go

package jsoni

import (
	"context"
	"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(ctx context.Context, obj interface{}) {
	iter := any.cfg.BorrowIterator(any.buf)
	defer any.cfg.ReturnIterator(iter)
	iter.ReadVal(ctx, 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 {
	var 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(_ context.Context, stream *Stream) {
	stream.Write(any.buf)
}

func (any *objectLazyAny) GetInterface(ctx context.Context) interface{} {
	iter := any.cfg.BorrowIterator(any.buf)
	defer any.cfg.ReturnIterator(iter)
	return iter.Read(ctx)
}

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(ctx context.Context, stream *Stream) {
	stream.WriteVal(ctx, any.val)
}

func (any *objectAny) GetInterface(context.Context) 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(ctx context.Context, stream *Stream) { stream.WriteVal(ctx, any.val) }
func (any *mapAny) GetInterface(context.Context) interface{}    { return any.val.Interface() }