mirror of
https://github.com/json-iterator/go.git
synced 2025-02-19 19:59:49 +02:00
109 lines
2.8 KiB
Go
109 lines
2.8 KiB
Go
package jsoniter
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"reflect"
|
|
"unsafe"
|
|
"github.com/v2pro/plz/reflect2"
|
|
)
|
|
|
|
func decoderOfSlice(cfg *frozenConfig, prefix string, typ reflect.Type) ValDecoder {
|
|
decoder := decoderOfType(cfg, prefix+"[slice]->", typ.Elem())
|
|
sliceType := reflect2.Type2(typ).(*reflect2.UnsafeSliceType)
|
|
return &sliceDecoder{sliceType, decoder}
|
|
}
|
|
|
|
func encoderOfSlice(cfg *frozenConfig, prefix string, typ reflect.Type) ValEncoder {
|
|
encoder := encoderOfType(cfg, prefix+"[slice]->", typ.Elem())
|
|
sliceType := reflect2.Type2(typ).(*reflect2.UnsafeSliceType)
|
|
return &sliceEncoder{sliceType, encoder}
|
|
}
|
|
|
|
type sliceEncoder struct {
|
|
sliceType *reflect2.UnsafeSliceType
|
|
elemEncoder ValEncoder
|
|
}
|
|
|
|
func (encoder *sliceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
if encoder.sliceType.UnsafeIsNil(ptr) {
|
|
stream.WriteNil()
|
|
return
|
|
}
|
|
length := encoder.sliceType.UnsafeLengthOf(ptr)
|
|
if length == 0 {
|
|
stream.WriteEmptyArray()
|
|
return
|
|
}
|
|
stream.WriteArrayStart()
|
|
encoder.elemEncoder.Encode(encoder.sliceType.UnsafeGetIndex(ptr, 0), stream)
|
|
for i := 1; i < length; i++ {
|
|
stream.WriteMore()
|
|
elemPtr := encoder.sliceType.UnsafeGetIndex(ptr, i)
|
|
encoder.elemEncoder.Encode(elemPtr, stream)
|
|
}
|
|
stream.WriteArrayEnd()
|
|
if stream.Error != nil && stream.Error != io.EOF {
|
|
stream.Error = fmt.Errorf("%v: %s", encoder.sliceType, stream.Error.Error())
|
|
}
|
|
}
|
|
|
|
func (encoder *sliceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
|
|
slice := (*sliceHeader)(ptr)
|
|
return slice.Len == 0
|
|
}
|
|
|
|
type sliceDecoder struct {
|
|
sliceType *reflect2.UnsafeSliceType
|
|
elemDecoder ValDecoder
|
|
}
|
|
|
|
// sliceHeader is a safe version of SliceHeader used within this package.
|
|
type sliceHeader struct {
|
|
Data unsafe.Pointer
|
|
Len int
|
|
Cap int
|
|
}
|
|
|
|
func (decoder *sliceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
decoder.doDecode(ptr, iter)
|
|
if iter.Error != nil && iter.Error != io.EOF {
|
|
iter.Error = fmt.Errorf("%v: %s", decoder.sliceType, iter.Error.Error())
|
|
}
|
|
}
|
|
|
|
func (decoder *sliceDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
|
|
c := iter.nextToken()
|
|
sliceType := decoder.sliceType
|
|
if c == 'n' {
|
|
iter.skipThreeBytes('u', 'l', 'l')
|
|
sliceType.UnsafeSetNil(ptr)
|
|
return
|
|
}
|
|
if c != '[' {
|
|
iter.ReportError("decode array", "expect [ or n, but found "+string([]byte{c}))
|
|
return
|
|
}
|
|
c = iter.nextToken()
|
|
if c == ']' {
|
|
sliceType.Set(ptr, sliceType.UnsafeNew())
|
|
return
|
|
}
|
|
iter.unreadByte()
|
|
sliceType.UnsafeGrow(ptr, 1)
|
|
elemPtr := sliceType.UnsafeGetIndex(ptr, 0)
|
|
decoder.elemDecoder.Decode(elemPtr, iter)
|
|
length := 1
|
|
for c = iter.nextToken(); c == ','; c = iter.nextToken() {
|
|
idx := length
|
|
length += 1
|
|
sliceType.UnsafeGrow(ptr, length)
|
|
elemPtr = sliceType.UnsafeGetIndex(ptr, idx)
|
|
decoder.elemDecoder.Decode(elemPtr, iter)
|
|
}
|
|
if c != ']' {
|
|
iter.ReportError("decode array", "expect ], but found "+string([]byte{c}))
|
|
return
|
|
}
|
|
}
|