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

package jsoni

import (
	"context"
	"errors"
	"fmt"
	"io"
	"reflect"
	"strconv"
	"unsafe"

	"github.com/modern-go/reflect2"
)

// Any generic object representation.
// The lazy json implementation holds []byte and parse lazily.
type Any interface {
	LastError() error
	ValueType() ValueType
	MustBeValid() Any
	ToBool() bool
	ToInt() int
	ToInt32() int32
	ToInt64() int64
	ToUint() uint
	ToUint32() uint32
	ToUint64() uint64
	ToFloat32() float32
	ToFloat64() float64
	ToString() string
	ToVal(ctx context.Context, val interface{})
	Get(path ...interface{}) Any
	Size() int
	Keys() []string
	GetInterface(ctx context.Context) interface{}
	WriteTo(ctx context.Context, stream *Stream)
}

type baseAny struct{}

func (any *baseAny) Get(path ...interface{}) Any {
	return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)}
}

func (any *baseAny) Size() int                          { return 0 }
func (any *baseAny) Keys() []string                     { return []string{} }
func (any *baseAny) ToVal(context.Context, interface{}) { panic("not implemented") }

// WrapInt32 turn int32 into Any interface
func WrapInt32(val int32) Any { return &int32Any{baseAny{}, val} }

// WrapInt64 turn int64 into Any interface
func WrapInt64(val int64) Any { return &int64Any{baseAny{}, val} }

// WrapUint32 turn uint32 into Any interface
func WrapUint32(val uint32) Any { return &uint32Any{baseAny{}, val} }

// WrapUint64 turn uint64 into Any interface
func WrapUint64(val uint64) Any { return &uint64Any{baseAny{}, val} }

// WrapFloat64 turn float64 into Any interface
func WrapFloat64(val float64) Any { return &floatAny{baseAny{}, val} }

// WrapString turn string into Any interface
func WrapString(val string) Any { return &stringAny{baseAny{}, val} }

// Wrap turn a go object into Any interface
func Wrap(val interface{}) Any {
	if val == nil {
		return &nilAny{}
	}
	asAny, isAny := val.(Any)
	if isAny {
		return asAny
	}
	typ := reflect2.TypeOf(val)
	switch typ.Kind() {
	case reflect.Slice:
		return wrapArray(val)
	case reflect.Struct:
		return wrapStruct(val)
	case reflect.Map:
		return wrapMap(val)
	case reflect.String:
		return WrapString(val.(string))
	case reflect.Int:
		if strconv.IntSize == 32 {
			return WrapInt32(int32(val.(int)))
		}
		return WrapInt64(int64(val.(int)))
	case reflect.Int8:
		return WrapInt32(int32(val.(int8)))
	case reflect.Int16:
		return WrapInt32(int32(val.(int16)))
	case reflect.Int32:
		return WrapInt32(val.(int32))
	case reflect.Int64:
		return WrapInt64(val.(int64))
	case reflect.Uint:
		if strconv.IntSize == 32 {
			return WrapUint32(uint32(val.(uint)))
		}
		return WrapUint64(uint64(val.(uint)))
	case reflect.Uintptr:
		if ptrSize == 32 {
			return WrapUint32(uint32(val.(uintptr)))
		}
		return WrapUint64(uint64(val.(uintptr)))
	case reflect.Uint8:
		return WrapUint32(uint32(val.(uint8)))
	case reflect.Uint16:
		return WrapUint32(uint32(val.(uint16)))
	case reflect.Uint32:
		return WrapUint32(val.(uint32))
	case reflect.Uint64:
		return WrapUint64(val.(uint64))
	case reflect.Float32:
		return WrapFloat64(float64(val.(float32)))
	case reflect.Float64:
		return WrapFloat64(val.(float64))
	case reflect.Bool:
		if val.(bool) == true {
			return &trueAny{}
		}
		return &falseAny{}
	}
	return &invalidAny{baseAny{}, fmt.Errorf("unsupported type: %v", typ)}
}

// ReadAny read next JSON element as an Any object. It is a better json.RawMessage.
func (iter *Iterator) ReadAny() Any {
	return iter.readAny()
}

func (iter *Iterator) readAny() Any {
	c := iter.nextToken()
	switch c {
	case '"':
		iter.unreadByte()
		return &stringAny{baseAny{}, iter.ReadString()}
	case 'n':
		iter.skip3Bytes('u', 'l', 'l') // null
		return &nilAny{}
	case 't':
		iter.skip3Bytes('r', 'u', 'e') // true
		return &trueAny{}
	case 'f':
		iter.skip4Bytes('a', 'l', 's', 'e') // false
		return &falseAny{}
	case '{':
		return iter.readObjectAny()
	case '[':
		return iter.readArrayAny()
	case '-':
		return iter.readNumberAny(false)
	case 0:
		return &invalidAny{baseAny{}, errors.New("input is empty")}
	default:
		return iter.readNumberAny(true)
	}
}

func (iter *Iterator) readNumberAny(positive bool) Any {
	iter.startCapture(iter.head - 1)
	iter.skipNumber()
	lazyBuf := iter.stopCapture()
	return &numberLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
}

func (iter *Iterator) readObjectAny() Any {
	iter.startCapture(iter.head - 1)
	iter.skipObject()
	lazyBuf := iter.stopCapture()
	return &objectLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
}

func (iter *Iterator) readArrayAny() Any {
	iter.startCapture(iter.head - 1)
	iter.skipArray()
	lazyBuf := iter.stopCapture()
	return &arrayLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
}

func locateObjectField(iter *Iterator, target string) []byte {
	var found []byte
	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
		if field == target {
			found = iter.SkipAndReturnBytes()
			return false
		}
		iter.Skip()
		return true
	})
	return found
}

func locateArrayElement(iter *Iterator, target int) []byte {
	var found []byte
	n := 0
	iter.ReadArrayCB(func(iter *Iterator) bool {
		if n == target {
			found = iter.SkipAndReturnBytes()
			return false
		}
		iter.Skip()
		n++
		return true
	})
	return found
}

func locatePath(iter *Iterator, path []interface{}) Any {
	for i, pathKeyObj := range path {
		switch pathKey := pathKeyObj.(type) {
		case string:
			valueBytes := locateObjectField(iter, pathKey)
			if valueBytes == nil {
				return newInvalidAny(path[i:])
			}
			iter.ResetBytes(valueBytes)
		case int:
			valueBytes := locateArrayElement(iter, pathKey)
			if valueBytes == nil {
				return newInvalidAny(path[i:])
			}
			iter.ResetBytes(valueBytes)
		case int32:
			if '*' == pathKey {
				return iter.readAny().Get(path[i:]...)
			}
			return newInvalidAny(path[i:])
		default:
			return newInvalidAny(path[i:])
		}
	}
	if iter.Error != nil && iter.Error != io.EOF {
		return &invalidAny{baseAny{}, iter.Error}
	}
	return iter.readAny()
}

var anyType = PtrElem((*Any)(nil))

func createDecoderOfAny(_ *ctx, typ reflect2.Type) ValDecoder {
	if typ == anyType {
		return &directAnyCodec{}
	}
	if typ.Implements(anyType) {
		return &anyCodec{valType: typ}
	}
	return nil
}

func createEncoderOfAny(_ *ctx, typ reflect2.Type) ValEncoder {
	if typ == anyType {
		return &directAnyCodec{}
	}
	if typ.Implements(anyType) {
		return &anyCodec{valType: typ}
	}
	return nil
}

type anyCodec struct {
	valType reflect2.Type
}

func (c *anyCodec) Decode(context.Context, unsafe.Pointer, *Iterator) { panic("not implemented") }

func (c *anyCodec) Encode(ctx context.Context, ptr unsafe.Pointer, stream *Stream) {
	obj := c.valType.UnsafeIndirect(ptr)
	any := obj.(Any)
	any.WriteTo(ctx, stream)
}

func (c *anyCodec) IsEmpty(_ context.Context, ptr unsafe.Pointer, _ bool) bool {
	obj := c.valType.UnsafeIndirect(ptr)
	any := obj.(Any)
	return any.Size() == 0
}

type directAnyCodec struct{}

func (c *directAnyCodec) Decode(_ context.Context, ptr unsafe.Pointer, iter *Iterator) {
	*(*Any)(ptr) = iter.readAny()
}

func (c *directAnyCodec) Encode(ctx context.Context, ptr unsafe.Pointer, stream *Stream) {
	any := *(*Any)(ptr)
	if any == nil {
		stream.WriteNil()
		return
	}
	any.WriteTo(ctx, stream)
}

func (c *directAnyCodec) IsEmpty(_ context.Context, ptr unsafe.Pointer, _ bool) bool {
	any := *(*Any)(ptr)
	return any.Size() == 0
}