mirror of
https://github.com/json-iterator/go.git
synced 2025-02-07 19:30:06 +02:00
fix build; add document for exported symbols
This commit is contained in:
Tao Wen
parent
d3448d3dbd
commit
bede1d7f40
@ -134,7 +134,7 @@ type htmlEscapedStringEncoder struct {
|
||||
|
||||
func (encoder *htmlEscapedStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
|
||||
str := *((*string)(ptr))
|
||||
stream.WriteStringWithHtmlEscaped(str)
|
||||
stream.WriteStringWithHTMLEscaped(str)
|
||||
}
|
||||
|
||||
func (encoder *htmlEscapedStringEncoder) EncodeInterface(val interface{}, stream *Stream) {
|
||||
|
||||
@ -102,9 +102,9 @@ non_decimal_loop:
|
||||
ind := floatDigits[c]
|
||||
switch ind {
|
||||
case endOfNumber:
|
||||
if decimalPlaces > 0 && decimalPlaces < len(_POW10) {
|
||||
if decimalPlaces > 0 && decimalPlaces < len(pow10) {
|
||||
iter.head = i
|
||||
return float32(float64(value) / float64(_POW10[decimalPlaces]))
|
||||
return float32(float64(value) / float64(pow10[decimalPlaces]))
|
||||
}
|
||||
// too many decimal places
|
||||
return iter.readFloat32SlowPath()
|
||||
@ -205,9 +205,9 @@ non_decimal_loop:
|
||||
ind := floatDigits[c]
|
||||
switch ind {
|
||||
case endOfNumber:
|
||||
if decimalPlaces > 0 && decimalPlaces < len(_POW10) {
|
||||
if decimalPlaces > 0 && decimalPlaces < len(pow10) {
|
||||
iter.head = i
|
||||
return float64(value) / float64(_POW10[decimalPlaces])
|
||||
return float64(value) / float64(pow10[decimalPlaces])
|
||||
}
|
||||
// too many decimal places
|
||||
return iter.readFloat64SlowPath()
|
||||
|
||||
@ -24,177 +24,177 @@ func NewStream(cfg *frozenConfig, out io.Writer, bufSize int) *Stream {
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Stream) Reset(out io.Writer) {
|
||||
b.out = out
|
||||
b.n = 0
|
||||
func (stream *Stream) Reset(out io.Writer) {
|
||||
stream.out = out
|
||||
stream.n = 0
|
||||
}
|
||||
|
||||
// Available returns how many bytes are unused in the buffer.
|
||||
func (b *Stream) Available() int {
|
||||
return len(b.buf) - b.n
|
||||
func (stream *Stream) Available() int {
|
||||
return len(stream.buf) - stream.n
|
||||
}
|
||||
|
||||
// Buffered returns the number of bytes that have been written into the current buffer.
|
||||
func (b *Stream) Buffered() int {
|
||||
return b.n
|
||||
func (stream *Stream) Buffered() int {
|
||||
return stream.n
|
||||
}
|
||||
|
||||
func (b *Stream) Buffer() []byte {
|
||||
return b.buf[:b.n]
|
||||
func (stream *Stream) Buffer() []byte {
|
||||
return stream.buf[:stream.n]
|
||||
}
|
||||
|
||||
// Write writes the contents of p into the buffer.
|
||||
// It returns the number of bytes written.
|
||||
// If nn < len(p), it also returns an error explaining
|
||||
// why the write is short.
|
||||
func (b *Stream) Write(p []byte) (nn int, err error) {
|
||||
for len(p) > b.Available() && b.Error == nil {
|
||||
if b.out == nil {
|
||||
b.growAtLeast(len(p))
|
||||
func (stream *Stream) Write(p []byte) (nn int, err error) {
|
||||
for len(p) > stream.Available() && stream.Error == nil {
|
||||
if stream.out == nil {
|
||||
stream.growAtLeast(len(p))
|
||||
} else {
|
||||
var n int
|
||||
if b.Buffered() == 0 {
|
||||
if stream.Buffered() == 0 {
|
||||
// Large write, empty buffer.
|
||||
// Write directly from p to avoid copy.
|
||||
n, b.Error = b.out.Write(p)
|
||||
n, stream.Error = stream.out.Write(p)
|
||||
} else {
|
||||
n = copy(b.buf[b.n:], p)
|
||||
b.n += n
|
||||
b.Flush()
|
||||
n = copy(stream.buf[stream.n:], p)
|
||||
stream.n += n
|
||||
stream.Flush()
|
||||
}
|
||||
nn += n
|
||||
p = p[n:]
|
||||
}
|
||||
}
|
||||
if b.Error != nil {
|
||||
return nn, b.Error
|
||||
if stream.Error != nil {
|
||||
return nn, stream.Error
|
||||
}
|
||||
n := copy(b.buf[b.n:], p)
|
||||
b.n += n
|
||||
n := copy(stream.buf[stream.n:], p)
|
||||
stream.n += n
|
||||
nn += n
|
||||
return nn, nil
|
||||
}
|
||||
|
||||
// WriteByte writes a single byte.
|
||||
func (b *Stream) writeByte(c byte) {
|
||||
if b.Error != nil {
|
||||
func (stream *Stream) writeByte(c byte) {
|
||||
if stream.Error != nil {
|
||||
return
|
||||
}
|
||||
if b.Available() < 1 {
|
||||
b.growAtLeast(1)
|
||||
if stream.Available() < 1 {
|
||||
stream.growAtLeast(1)
|
||||
}
|
||||
b.buf[b.n] = c
|
||||
b.n++
|
||||
stream.buf[stream.n] = c
|
||||
stream.n++
|
||||
}
|
||||
|
||||
func (b *Stream) writeTwoBytes(c1 byte, c2 byte) {
|
||||
if b.Error != nil {
|
||||
func (stream *Stream) writeTwoBytes(c1 byte, c2 byte) {
|
||||
if stream.Error != nil {
|
||||
return
|
||||
}
|
||||
if b.Available() < 2 {
|
||||
b.growAtLeast(2)
|
||||
if stream.Available() < 2 {
|
||||
stream.growAtLeast(2)
|
||||
}
|
||||
b.buf[b.n] = c1
|
||||
b.buf[b.n+1] = c2
|
||||
b.n += 2
|
||||
stream.buf[stream.n] = c1
|
||||
stream.buf[stream.n+1] = c2
|
||||
stream.n += 2
|
||||
}
|
||||
|
||||
func (b *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
|
||||
if b.Error != nil {
|
||||
func (stream *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
|
||||
if stream.Error != nil {
|
||||
return
|
||||
}
|
||||
if b.Available() < 3 {
|
||||
b.growAtLeast(3)
|
||||
if stream.Available() < 3 {
|
||||
stream.growAtLeast(3)
|
||||
}
|
||||
b.buf[b.n] = c1
|
||||
b.buf[b.n+1] = c2
|
||||
b.buf[b.n+2] = c3
|
||||
b.n += 3
|
||||
stream.buf[stream.n] = c1
|
||||
stream.buf[stream.n+1] = c2
|
||||
stream.buf[stream.n+2] = c3
|
||||
stream.n += 3
|
||||
}
|
||||
|
||||
func (b *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
|
||||
if b.Error != nil {
|
||||
func (stream *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
|
||||
if stream.Error != nil {
|
||||
return
|
||||
}
|
||||
if b.Available() < 4 {
|
||||
b.growAtLeast(4)
|
||||
if stream.Available() < 4 {
|
||||
stream.growAtLeast(4)
|
||||
}
|
||||
b.buf[b.n] = c1
|
||||
b.buf[b.n+1] = c2
|
||||
b.buf[b.n+2] = c3
|
||||
b.buf[b.n+3] = c4
|
||||
b.n += 4
|
||||
stream.buf[stream.n] = c1
|
||||
stream.buf[stream.n+1] = c2
|
||||
stream.buf[stream.n+2] = c3
|
||||
stream.buf[stream.n+3] = c4
|
||||
stream.n += 4
|
||||
}
|
||||
|
||||
func (b *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
|
||||
if b.Error != nil {
|
||||
func (stream *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
|
||||
if stream.Error != nil {
|
||||
return
|
||||
}
|
||||
if b.Available() < 5 {
|
||||
b.growAtLeast(5)
|
||||
if stream.Available() < 5 {
|
||||
stream.growAtLeast(5)
|
||||
}
|
||||
b.buf[b.n] = c1
|
||||
b.buf[b.n+1] = c2
|
||||
b.buf[b.n+2] = c3
|
||||
b.buf[b.n+3] = c4
|
||||
b.buf[b.n+4] = c5
|
||||
b.n += 5
|
||||
stream.buf[stream.n] = c1
|
||||
stream.buf[stream.n+1] = c2
|
||||
stream.buf[stream.n+2] = c3
|
||||
stream.buf[stream.n+3] = c4
|
||||
stream.buf[stream.n+4] = c5
|
||||
stream.n += 5
|
||||
}
|
||||
|
||||
// Flush writes any buffered data to the underlying io.Writer.
|
||||
func (b *Stream) Flush() error {
|
||||
if b.out == nil {
|
||||
func (stream *Stream) Flush() error {
|
||||
if stream.out == nil {
|
||||
return nil
|
||||
}
|
||||
if b.Error != nil {
|
||||
return b.Error
|
||||
if stream.Error != nil {
|
||||
return stream.Error
|
||||
}
|
||||
if b.n == 0 {
|
||||
if stream.n == 0 {
|
||||
return nil
|
||||
}
|
||||
n, err := b.out.Write(b.buf[0:b.n])
|
||||
if n < b.n && err == nil {
|
||||
n, err := stream.out.Write(stream.buf[0:stream.n])
|
||||
if n < stream.n && err == nil {
|
||||
err = io.ErrShortWrite
|
||||
}
|
||||
if err != nil {
|
||||
if n > 0 && n < b.n {
|
||||
copy(b.buf[0:b.n-n], b.buf[n:b.n])
|
||||
if n > 0 && n < stream.n {
|
||||
copy(stream.buf[0:stream.n-n], stream.buf[n:stream.n])
|
||||
}
|
||||
b.n -= n
|
||||
b.Error = err
|
||||
stream.n -= n
|
||||
stream.Error = err
|
||||
return err
|
||||
}
|
||||
b.n = 0
|
||||
stream.n = 0
|
||||
return nil
|
||||
}
|
||||
|
||||
func (b *Stream) ensure(minimal int) {
|
||||
available := b.Available()
|
||||
func (stream *Stream) ensure(minimal int) {
|
||||
available := stream.Available()
|
||||
if available < minimal {
|
||||
if b.n > 1024 {
|
||||
b.Flush()
|
||||
if stream.n > 1024 {
|
||||
stream.Flush()
|
||||
}
|
||||
b.growAtLeast(minimal)
|
||||
stream.growAtLeast(minimal)
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Stream) growAtLeast(minimal int) {
|
||||
toGrow := len(b.buf)
|
||||
func (stream *Stream) growAtLeast(minimal int) {
|
||||
toGrow := len(stream.buf)
|
||||
if toGrow < minimal {
|
||||
toGrow = minimal
|
||||
}
|
||||
newBuf := make([]byte, len(b.buf)+toGrow)
|
||||
copy(newBuf, b.Buffer())
|
||||
b.buf = newBuf
|
||||
newBuf := make([]byte, len(stream.buf)+toGrow)
|
||||
copy(newBuf, stream.Buffer())
|
||||
stream.buf = newBuf
|
||||
}
|
||||
|
||||
func (b *Stream) WriteRaw(s string) {
|
||||
b.ensure(len(s))
|
||||
if b.Error != nil {
|
||||
func (stream *Stream) WriteRaw(s string) {
|
||||
stream.ensure(len(s))
|
||||
if stream.Error != nil {
|
||||
return
|
||||
}
|
||||
n := copy(b.buf[b.n:], s)
|
||||
b.n += n
|
||||
n := copy(stream.buf[stream.n:], s)
|
||||
stream.n += n
|
||||
}
|
||||
|
||||
func (stream *Stream) WriteNil() {
|
||||
|
||||
@ -5,12 +5,13 @@ import (
|
||||
"strconv"
|
||||
)
|
||||
|
||||
var _POW10 []uint64
|
||||
var pow10 []uint64
|
||||
|
||||
func init() {
|
||||
_POW10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
|
||||
pow10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
|
||||
}
|
||||
|
||||
// WriteFloat32 write float32 to stream
|
||||
func (stream *Stream) WriteFloat32(val float32) {
|
||||
abs := math.Abs(float64(val))
|
||||
fmt := byte('f')
|
||||
@ -23,6 +24,7 @@ func (stream *Stream) WriteFloat32(val float32) {
|
||||
stream.WriteRaw(strconv.FormatFloat(float64(val), fmt, -1, 32))
|
||||
}
|
||||
|
||||
// WriteFloat32Lossy write float32 to stream with ONLY 6 digits precision although much much faster
|
||||
func (stream *Stream) WriteFloat32Lossy(val float32) {
|
||||
if val < 0 {
|
||||
stream.writeByte('-')
|
||||
@ -42,7 +44,7 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
|
||||
}
|
||||
stream.writeByte('.')
|
||||
stream.ensure(10)
|
||||
for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
|
||||
for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
|
||||
stream.writeByte('0')
|
||||
}
|
||||
stream.WriteUint64(fval)
|
||||
@ -51,6 +53,7 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
|
||||
}
|
||||
}
|
||||
|
||||
// WriteFloat64 write float64 to stream
|
||||
func (stream *Stream) WriteFloat64(val float64) {
|
||||
abs := math.Abs(val)
|
||||
fmt := byte('f')
|
||||
@ -63,6 +66,7 @@ func (stream *Stream) WriteFloat64(val float64) {
|
||||
stream.WriteRaw(strconv.FormatFloat(float64(val), fmt, -1, 64))
|
||||
}
|
||||
|
||||
// WriteFloat64Lossy write float64 to stream with ONLY 6 digits precision although much much faster
|
||||
func (stream *Stream) WriteFloat64Lossy(val float64) {
|
||||
if val < 0 {
|
||||
stream.writeByte('-')
|
||||
@ -82,7 +86,7 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
|
||||
}
|
||||
stream.writeByte('.')
|
||||
stream.ensure(10)
|
||||
for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
|
||||
for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
|
||||
stream.writeByte('0')
|
||||
}
|
||||
stream.WriteUint64(fval)
|
||||
|
||||
@ -1,15 +1,15 @@
|
||||
package jsoniter
|
||||
|
||||
var _DIGITS []uint32
|
||||
var digits []uint32
|
||||
|
||||
func init() {
|
||||
_DIGITS = make([]uint32, 1000)
|
||||
digits = make([]uint32, 1000)
|
||||
for i := uint32(0); i < 1000; i++ {
|
||||
_DIGITS[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
|
||||
digits[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
|
||||
if i < 10 {
|
||||
_DIGITS[i] += 2 << 24
|
||||
digits[i] += 2 << 24
|
||||
} else if i < 100 {
|
||||
_DIGITS[i] += 1 << 24
|
||||
digits[i] += 1 << 24
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -36,11 +36,13 @@ func writeBuf(buf []byte, v uint32, n int) {
|
||||
buf[n+2] = byte(v)
|
||||
}
|
||||
|
||||
// WriteUint8 write uint8 to stream
|
||||
func (stream *Stream) WriteUint8(val uint8) {
|
||||
stream.ensure(3)
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], stream.n)
|
||||
}
|
||||
|
||||
// WriteInt8 write int8 to stream
|
||||
func (stream *Stream) WriteInt8(nval int8) {
|
||||
stream.ensure(4)
|
||||
n := stream.n
|
||||
@ -52,23 +54,25 @@ func (stream *Stream) WriteInt8(nval int8) {
|
||||
} else {
|
||||
val = uint8(nval)
|
||||
}
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], n)
|
||||
}
|
||||
|
||||
// WriteUint16 write uint16 to stream
|
||||
func (stream *Stream) WriteUint16(val uint16) {
|
||||
stream.ensure(5)
|
||||
q1 := val / 1000
|
||||
if q1 == 0 {
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], stream.n)
|
||||
return
|
||||
}
|
||||
r1 := val - q1*1000
|
||||
n := writeFirstBuf(stream.buf, _DIGITS[q1], stream.n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n)
|
||||
n := writeFirstBuf(stream.buf, digits[q1], stream.n)
|
||||
writeBuf(stream.buf, digits[r1], n)
|
||||
stream.n = n + 3
|
||||
return
|
||||
}
|
||||
|
||||
// WriteInt16 write int16 to stream
|
||||
func (stream *Stream) WriteInt16(nval int16) {
|
||||
stream.ensure(6)
|
||||
n := stream.n
|
||||
@ -82,48 +86,50 @@ func (stream *Stream) WriteInt16(nval int16) {
|
||||
}
|
||||
q1 := val / 1000
|
||||
if q1 == 0 {
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], n)
|
||||
return
|
||||
}
|
||||
r1 := val - q1*1000
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q1], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n)
|
||||
n = writeFirstBuf(stream.buf, digits[q1], n)
|
||||
writeBuf(stream.buf, digits[r1], n)
|
||||
stream.n = n + 3
|
||||
return
|
||||
}
|
||||
|
||||
// WriteUint32 write uint32 to stream
|
||||
func (stream *Stream) WriteUint32(val uint32) {
|
||||
stream.ensure(10)
|
||||
n := stream.n
|
||||
q1 := val / 1000
|
||||
if q1 == 0 {
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], n)
|
||||
return
|
||||
}
|
||||
r1 := val - q1*1000
|
||||
q2 := q1 / 1000
|
||||
if q2 == 0 {
|
||||
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n)
|
||||
n := writeFirstBuf(stream.buf, digits[q1], n)
|
||||
writeBuf(stream.buf, digits[r1], n)
|
||||
stream.n = n + 3
|
||||
return
|
||||
}
|
||||
r2 := q1 - q2*1000
|
||||
q3 := q2 / 1000
|
||||
if q3 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
|
||||
n = writeFirstBuf(stream.buf, digits[q2], n)
|
||||
} else {
|
||||
r3 := q2 - q3*1000
|
||||
stream.buf[n] = byte(q3 + '0')
|
||||
n++
|
||||
writeBuf(stream.buf, _DIGITS[r3], n)
|
||||
writeBuf(stream.buf, digits[r3], n)
|
||||
n += 3
|
||||
}
|
||||
writeBuf(stream.buf, _DIGITS[r2], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+3)
|
||||
writeBuf(stream.buf, digits[r2], n)
|
||||
writeBuf(stream.buf, digits[r1], n+3)
|
||||
stream.n = n + 6
|
||||
}
|
||||
|
||||
// WriteInt32 write int32 to stream
|
||||
func (stream *Stream) WriteInt32(nval int32) {
|
||||
stream.ensure(11)
|
||||
n := stream.n
|
||||
@ -137,97 +143,99 @@ func (stream *Stream) WriteInt32(nval int32) {
|
||||
}
|
||||
q1 := val / 1000
|
||||
if q1 == 0 {
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], n)
|
||||
return
|
||||
}
|
||||
r1 := val - q1*1000
|
||||
q2 := q1 / 1000
|
||||
if q2 == 0 {
|
||||
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n)
|
||||
n := writeFirstBuf(stream.buf, digits[q1], n)
|
||||
writeBuf(stream.buf, digits[r1], n)
|
||||
stream.n = n + 3
|
||||
return
|
||||
}
|
||||
r2 := q1 - q2*1000
|
||||
q3 := q2 / 1000
|
||||
if q3 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
|
||||
n = writeFirstBuf(stream.buf, digits[q2], n)
|
||||
} else {
|
||||
r3 := q2 - q3*1000
|
||||
stream.buf[n] = byte(q3 + '0')
|
||||
n++
|
||||
writeBuf(stream.buf, _DIGITS[r3], n)
|
||||
writeBuf(stream.buf, digits[r3], n)
|
||||
n += 3
|
||||
}
|
||||
writeBuf(stream.buf, _DIGITS[r2], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+3)
|
||||
writeBuf(stream.buf, digits[r2], n)
|
||||
writeBuf(stream.buf, digits[r1], n+3)
|
||||
stream.n = n + 6
|
||||
}
|
||||
|
||||
// WriteUint64 write uint64 to stream
|
||||
func (stream *Stream) WriteUint64(val uint64) {
|
||||
stream.ensure(20)
|
||||
n := stream.n
|
||||
q1 := val / 1000
|
||||
if q1 == 0 {
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], n)
|
||||
return
|
||||
}
|
||||
r1 := val - q1*1000
|
||||
q2 := q1 / 1000
|
||||
if q2 == 0 {
|
||||
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n)
|
||||
n := writeFirstBuf(stream.buf, digits[q1], n)
|
||||
writeBuf(stream.buf, digits[r1], n)
|
||||
stream.n = n + 3
|
||||
return
|
||||
}
|
||||
r2 := q1 - q2*1000
|
||||
q3 := q2 / 1000
|
||||
if q3 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+3)
|
||||
n = writeFirstBuf(stream.buf, digits[q2], n)
|
||||
writeBuf(stream.buf, digits[r2], n)
|
||||
writeBuf(stream.buf, digits[r1], n+3)
|
||||
stream.n = n + 6
|
||||
return
|
||||
}
|
||||
r3 := q2 - q3*1000
|
||||
q4 := q3 / 1000
|
||||
if q4 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
|
||||
writeBuf(stream.buf, _DIGITS[r3], n)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n+3)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+6)
|
||||
n = writeFirstBuf(stream.buf, digits[q3], n)
|
||||
writeBuf(stream.buf, digits[r3], n)
|
||||
writeBuf(stream.buf, digits[r2], n+3)
|
||||
writeBuf(stream.buf, digits[r1], n+6)
|
||||
stream.n = n + 9
|
||||
return
|
||||
}
|
||||
r4 := q3 - q4*1000
|
||||
q5 := q4 / 1000
|
||||
if q5 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
|
||||
writeBuf(stream.buf, _DIGITS[r4], n)
|
||||
writeBuf(stream.buf, _DIGITS[r3], n+3)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n+6)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+9)
|
||||
n = writeFirstBuf(stream.buf, digits[q4], n)
|
||||
writeBuf(stream.buf, digits[r4], n)
|
||||
writeBuf(stream.buf, digits[r3], n+3)
|
||||
writeBuf(stream.buf, digits[r2], n+6)
|
||||
writeBuf(stream.buf, digits[r1], n+9)
|
||||
stream.n = n + 12
|
||||
return
|
||||
}
|
||||
r5 := q4 - q5*1000
|
||||
q6 := q5 / 1000
|
||||
if q6 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
|
||||
n = writeFirstBuf(stream.buf, digits[q5], n)
|
||||
} else {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q6], n)
|
||||
n = writeFirstBuf(stream.buf, digits[q6], n)
|
||||
r6 := q5 - q6*1000
|
||||
writeBuf(stream.buf, _DIGITS[r6], n)
|
||||
writeBuf(stream.buf, digits[r6], n)
|
||||
n += 3
|
||||
}
|
||||
writeBuf(stream.buf, _DIGITS[r5], n)
|
||||
writeBuf(stream.buf, _DIGITS[r4], n+3)
|
||||
writeBuf(stream.buf, _DIGITS[r3], n+6)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n+9)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+12)
|
||||
writeBuf(stream.buf, digits[r5], n)
|
||||
writeBuf(stream.buf, digits[r4], n+3)
|
||||
writeBuf(stream.buf, digits[r3], n+6)
|
||||
writeBuf(stream.buf, digits[r2], n+9)
|
||||
writeBuf(stream.buf, digits[r1], n+12)
|
||||
stream.n = n + 15
|
||||
}
|
||||
|
||||
// WriteInt64 write int64 to stream
|
||||
func (stream *Stream) WriteInt64(nval int64) {
|
||||
stream.ensure(20)
|
||||
n := stream.n
|
||||
@ -241,70 +249,72 @@ func (stream *Stream) WriteInt64(nval int64) {
|
||||
}
|
||||
q1 := val / 1000
|
||||
if q1 == 0 {
|
||||
stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
|
||||
stream.n = writeFirstBuf(stream.buf, digits[val], n)
|
||||
return
|
||||
}
|
||||
r1 := val - q1*1000
|
||||
q2 := q1 / 1000
|
||||
if q2 == 0 {
|
||||
n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n)
|
||||
n := writeFirstBuf(stream.buf, digits[q1], n)
|
||||
writeBuf(stream.buf, digits[r1], n)
|
||||
stream.n = n + 3
|
||||
return
|
||||
}
|
||||
r2 := q1 - q2*1000
|
||||
q3 := q2 / 1000
|
||||
if q3 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+3)
|
||||
n = writeFirstBuf(stream.buf, digits[q2], n)
|
||||
writeBuf(stream.buf, digits[r2], n)
|
||||
writeBuf(stream.buf, digits[r1], n+3)
|
||||
stream.n = n + 6
|
||||
return
|
||||
}
|
||||
r3 := q2 - q3*1000
|
||||
q4 := q3 / 1000
|
||||
if q4 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
|
||||
writeBuf(stream.buf, _DIGITS[r3], n)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n+3)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+6)
|
||||
n = writeFirstBuf(stream.buf, digits[q3], n)
|
||||
writeBuf(stream.buf, digits[r3], n)
|
||||
writeBuf(stream.buf, digits[r2], n+3)
|
||||
writeBuf(stream.buf, digits[r1], n+6)
|
||||
stream.n = n + 9
|
||||
return
|
||||
}
|
||||
r4 := q3 - q4*1000
|
||||
q5 := q4 / 1000
|
||||
if q5 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
|
||||
writeBuf(stream.buf, _DIGITS[r4], n)
|
||||
writeBuf(stream.buf, _DIGITS[r3], n+3)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n+6)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+9)
|
||||
n = writeFirstBuf(stream.buf, digits[q4], n)
|
||||
writeBuf(stream.buf, digits[r4], n)
|
||||
writeBuf(stream.buf, digits[r3], n+3)
|
||||
writeBuf(stream.buf, digits[r2], n+6)
|
||||
writeBuf(stream.buf, digits[r1], n+9)
|
||||
stream.n = n + 12
|
||||
return
|
||||
}
|
||||
r5 := q4 - q5*1000
|
||||
q6 := q5 / 1000
|
||||
if q6 == 0 {
|
||||
n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
|
||||
n = writeFirstBuf(stream.buf, digits[q5], n)
|
||||
} else {
|
||||
stream.buf[n] = byte(q6 + '0')
|
||||
n++
|
||||
r6 := q5 - q6*1000
|
||||
writeBuf(stream.buf, _DIGITS[r6], n)
|
||||
writeBuf(stream.buf, digits[r6], n)
|
||||
n += 3
|
||||
}
|
||||
writeBuf(stream.buf, _DIGITS[r5], n)
|
||||
writeBuf(stream.buf, _DIGITS[r4], n+3)
|
||||
writeBuf(stream.buf, _DIGITS[r3], n+6)
|
||||
writeBuf(stream.buf, _DIGITS[r2], n+9)
|
||||
writeBuf(stream.buf, _DIGITS[r1], n+12)
|
||||
writeBuf(stream.buf, digits[r5], n)
|
||||
writeBuf(stream.buf, digits[r4], n+3)
|
||||
writeBuf(stream.buf, digits[r3], n+6)
|
||||
writeBuf(stream.buf, digits[r2], n+9)
|
||||
writeBuf(stream.buf, digits[r1], n+12)
|
||||
stream.n = n + 15
|
||||
}
|
||||
|
||||
// WriteInt write int to stream
|
||||
func (stream *Stream) WriteInt(val int) {
|
||||
stream.WriteInt64(int64(val))
|
||||
}
|
||||
|
||||
// WriteUint write uint to stream
|
||||
func (stream *Stream) WriteUint(val uint) {
|
||||
stream.WriteUint64(uint64(val))
|
||||
}
|
||||
|
||||
@ -217,7 +217,8 @@ var safeSet = [utf8.RuneSelf]bool{
|
||||
|
||||
var hex = "0123456789abcdef"
|
||||
|
||||
func (stream *Stream) WriteStringWithHtmlEscaped(s string) {
|
||||
// WriteStringWithHTMLEscaped write string to stream with html special characters escaped
|
||||
func (stream *Stream) WriteStringWithHTMLEscaped(s string) {
|
||||
stream.ensure(32)
|
||||
valLen := len(s)
|
||||
toWriteLen := valLen
|
||||
@ -246,10 +247,10 @@ func (stream *Stream) WriteStringWithHtmlEscaped(s string) {
|
||||
return
|
||||
}
|
||||
stream.n = n
|
||||
writeStringSlowPathWithHtmlEscaped(stream, i, s, valLen)
|
||||
writeStringSlowPathWithHTMLEscaped(stream, i, s, valLen)
|
||||
}
|
||||
|
||||
func writeStringSlowPathWithHtmlEscaped(stream *Stream, i int, s string, valLen int) {
|
||||
func writeStringSlowPathWithHTMLEscaped(stream *Stream, i int, s string, valLen int) {
|
||||
start := i
|
||||
// for the remaining parts, we process them char by char
|
||||
for i < valLen {
|
||||
@ -316,6 +317,7 @@ func writeStringSlowPathWithHtmlEscaped(stream *Stream, i int, s string, valLen
|
||||
stream.writeByte('"')
|
||||
}
|
||||
|
||||
// WriteString write string to stream without html escape
|
||||
func (stream *Stream) WriteString(s string) {
|
||||
stream.ensure(32)
|
||||
valLen := len(s)
|
||||
|
||||
@ -25,7 +25,7 @@ func Test_alias(t *testing.T) {
|
||||
type myuintptr uintptr
|
||||
var a struct {
|
||||
A myint8 `json:"a"`
|
||||
B myint16 `json:"b"`
|
||||
B myint16 `json:"stream"`
|
||||
C myint32 `json:"c"`
|
||||
D myint64 `json:"d"`
|
||||
E myuint8 `json:"e"`
|
||||
@ -41,7 +41,7 @@ func Test_alias(t *testing.T) {
|
||||
O myuintptr `json:"o"`
|
||||
}
|
||||
|
||||
should.Nil(UnmarshalFromString(`{"a" : 1, "b" : 1, "c": 1, "d" : 1, "e" : 1, "f" : 1, "g" : 1, "h": 1, "i" : 1, "j" : 1, "k" :"xxxx", "l" : 1, "m":1, "n": true, "o" : 1}`, &a))
|
||||
should.Nil(UnmarshalFromString(`{"a" : 1, "stream" : 1, "c": 1, "d" : 1, "e" : 1, "f" : 1, "g" : 1, "h": 1, "i" : 1, "j" : 1, "k" :"xxxx", "l" : 1, "m":1, "n": true, "o" : 1}`, &a))
|
||||
should.Equal(myfloat32(1), a.I)
|
||||
should.Equal(myfloat64(1), a.J)
|
||||
should.Equal(myint8(1), a.A)
|
||||
@ -57,6 +57,6 @@ func Test_alias(t *testing.T) {
|
||||
should.Equal(myuintptr(1), a.O)
|
||||
b, err := Marshal(a)
|
||||
should.Nil(err)
|
||||
should.Equal(`{"a":1,"b":1,"c":1,"d":1,"e":1,"f":1,"g":1,"h":1,"i":1,"j":1,"k":"xxxx","l":1,"m":1,"n":true,"o":1}`, string(b))
|
||||
should.Equal(`{"a":1,"stream":1,"c":1,"d":1,"e":1,"f":1,"g":1,"h":1,"i":1,"j":1,"k":"xxxx","l":1,"m":1,"n":true,"o":1}`, string(b))
|
||||
|
||||
}
|
||||
|
||||
@ -8,13 +8,13 @@ import (
|
||||
|
||||
func Test_read_object_as_any(t *testing.T) {
|
||||
should := require.New(t)
|
||||
any := Get([]byte(`{"a":"b","c":"d"}`))
|
||||
should.Equal(`{"a":"b","c":"d"}`, any.ToString())
|
||||
any := Get([]byte(`{"a":"stream","c":"d"}`))
|
||||
should.Equal(`{"a":"stream","c":"d"}`, any.ToString())
|
||||
// partial parse
|
||||
should.Equal("b", any.Get("a").ToString())
|
||||
should.Equal("stream", any.Get("a").ToString())
|
||||
should.Equal("d", any.Get("c").ToString())
|
||||
should.Equal(2, len(any.Keys()))
|
||||
any = Get([]byte(`{"a":"b","c":"d"}`))
|
||||
any = Get([]byte(`{"a":"stream","c":"d"}`))
|
||||
// full parse
|
||||
should.Equal(2, len(any.Keys()))
|
||||
should.Equal(2, any.Size())
|
||||
@ -22,30 +22,30 @@ func Test_read_object_as_any(t *testing.T) {
|
||||
should.Equal(0, any.ToInt())
|
||||
should.Equal(Object, any.ValueType())
|
||||
should.Nil(any.LastError())
|
||||
should.Equal("b", any.GetObject()["a"].ToString())
|
||||
should.Equal("stream", any.GetObject()["a"].ToString())
|
||||
obj := struct {
|
||||
A string
|
||||
}{}
|
||||
any.ToVal(&obj)
|
||||
should.Equal("b", obj.A)
|
||||
should.Equal("stream", obj.A)
|
||||
}
|
||||
|
||||
func Test_object_lazy_any_get(t *testing.T) {
|
||||
should := require.New(t)
|
||||
any := Get([]byte(`{"a":{"b":{"c":"d"}}}`))
|
||||
should.Equal("d", any.Get("a", "b", "c").ToString())
|
||||
any := Get([]byte(`{"a":{"stream":{"c":"d"}}}`))
|
||||
should.Equal("d", any.Get("a", "stream", "c").ToString())
|
||||
}
|
||||
|
||||
func Test_object_lazy_any_get_all(t *testing.T) {
|
||||
should := require.New(t)
|
||||
any := Get([]byte(`{"a":[0],"b":[1]}`))
|
||||
any := Get([]byte(`{"a":[0],"stream":[1]}`))
|
||||
should.Contains(any.Get('*', 0).ToString(), `"a":0`)
|
||||
}
|
||||
|
||||
func Test_object_lazy_any_get_invalid(t *testing.T) {
|
||||
should := require.New(t)
|
||||
any := Get([]byte(`{}`))
|
||||
should.Equal(Invalid, any.Get("a", "b", "c").ValueType())
|
||||
should.Equal(Invalid, any.Get("a", "stream", "c").ValueType())
|
||||
should.Equal(Invalid, any.Get(1).ValueType())
|
||||
}
|
||||
|
||||
|
||||
@ -26,7 +26,7 @@ var stringConvertMap = map[string]string{
|
||||
"[1,2]": "[1,2]",
|
||||
"{}": "{}",
|
||||
"{1,2}": "{1,2}",
|
||||
`{"a":1, "b":true}`: `{"a":1, "b":true}`,
|
||||
`{"a":1, "stream":true}`: `{"a":1, "stream":true}`,
|
||||
}
|
||||
|
||||
func Test_read_any_to_string(t *testing.T) {
|
||||
|
||||
@ -4,6 +4,7 @@ import (
|
||||
"bytes"
|
||||
"io"
|
||||
"testing"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func Test_read_by_one(t *testing.T) {
|
||||
@ -34,36 +35,21 @@ func Test_read_by_one(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_read_by_two(t *testing.T) {
|
||||
should := require.New(t)
|
||||
iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
|
||||
b := iter.readByte()
|
||||
if iter.Error != nil {
|
||||
t.Fatal(iter.Error)
|
||||
}
|
||||
if b != 'a' {
|
||||
t.Fatal(b)
|
||||
}
|
||||
should.Nil(iter.Error)
|
||||
should.Equal(byte('a'), b)
|
||||
b = iter.readByte()
|
||||
if iter.Error != nil {
|
||||
t.Fatal(iter.Error)
|
||||
}
|
||||
if b != 'b' {
|
||||
t.Fatal(b)
|
||||
}
|
||||
should.Nil(iter.Error)
|
||||
should.Equal(byte('b'), b)
|
||||
iter.unreadByte()
|
||||
if iter.Error != nil {
|
||||
t.Fatal(iter.Error)
|
||||
}
|
||||
should.Nil(iter.Error)
|
||||
iter.unreadByte()
|
||||
if iter.Error != nil {
|
||||
t.Fatal(iter.Error)
|
||||
}
|
||||
should.Nil(iter.Error)
|
||||
b = iter.readByte()
|
||||
if iter.Error != nil {
|
||||
t.Fatal(iter.Error)
|
||||
}
|
||||
if b != 'a' {
|
||||
t.Fatal(b)
|
||||
}
|
||||
should.Nil(iter.Error)
|
||||
should.Equal(byte('a'), b)
|
||||
}
|
||||
|
||||
func Test_read_until_eof(t *testing.T) {
|
||||
|
||||
@ -22,14 +22,14 @@ func Test_empty_object(t *testing.T) {
|
||||
|
||||
func Test_one_field(t *testing.T) {
|
||||
should := require.New(t)
|
||||
iter := ParseString(ConfigDefault, `{"a": "b"}`)
|
||||
iter := ParseString(ConfigDefault, `{"a": "stream"}`)
|
||||
field := iter.ReadObject()
|
||||
should.Equal("a", field)
|
||||
value := iter.ReadString()
|
||||
should.Equal("b", value)
|
||||
should.Equal("stream", value)
|
||||
field = iter.ReadObject()
|
||||
should.Equal("", field)
|
||||
iter = ParseString(ConfigDefault, `{"a": "b"}`)
|
||||
iter = ParseString(ConfigDefault, `{"a": "stream"}`)
|
||||
should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool {
|
||||
should.Equal("a", field)
|
||||
return true
|
||||
@ -39,11 +39,11 @@ func Test_one_field(t *testing.T) {
|
||||
|
||||
func Test_two_field(t *testing.T) {
|
||||
should := require.New(t)
|
||||
iter := ParseString(ConfigDefault, `{ "a": "b" , "c": "d" }`)
|
||||
iter := ParseString(ConfigDefault, `{ "a": "stream" , "c": "d" }`)
|
||||
field := iter.ReadObject()
|
||||
should.Equal("a", field)
|
||||
value := iter.ReadString()
|
||||
should.Equal("b", value)
|
||||
should.Equal("stream", value)
|
||||
field = iter.ReadObject()
|
||||
should.Equal("c", field)
|
||||
value = iter.ReadString()
|
||||
@ -115,9 +115,9 @@ func Test_decode_two_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
}
|
||||
|
||||
func Test_decode_three_fields_struct(t *testing.T) {
|
||||
@ -130,9 +130,9 @@ func Test_decode_three_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
}
|
||||
|
||||
@ -147,9 +147,9 @@ func Test_decode_four_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
}
|
||||
@ -166,9 +166,9 @@ func Test_decode_five_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
should.Equal("e", obj.Field5)
|
||||
@ -187,9 +187,9 @@ func Test_decode_six_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
should.Equal("e", obj.Field5)
|
||||
@ -210,9 +210,9 @@ func Test_decode_seven_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
should.Equal("e", obj.Field5)
|
||||
@ -235,9 +235,9 @@ func Test_decode_eight_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field8":"1", "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field8":"1", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
should.Equal("e", obj.Field5)
|
||||
@ -262,9 +262,9 @@ func Test_decode_nine_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field8" : "zzzzzzzzzzz", "Field7": "zz", "Field6" : "xx", "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e", "Field9":"f"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field8" : "zzzzzzzzzzz", "Field7": "zz", "Field6" : "xx", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field9":"f"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
should.Equal("e", obj.Field5)
|
||||
@ -291,9 +291,9 @@ func Test_decode_ten_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field10":"x", "Field9": "x", "Field8":"x", "Field7":"x", "Field6":"x", "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field10":"x", "Field9": "x", "Field8":"x", "Field7":"x", "Field6":"x", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
should.Equal("e", obj.Field5)
|
||||
@ -322,9 +322,9 @@ func Test_decode_more_than_ten_fields_struct(t *testing.T) {
|
||||
obj := TestObject{}
|
||||
should.Nil(UnmarshalFromString(`{}`, &obj))
|
||||
should.Equal("", obj.Field1)
|
||||
should.Nil(UnmarshalFromString(`{"Field11":1, "Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
|
||||
should.Nil(UnmarshalFromString(`{"Field11":1, "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
|
||||
should.Equal("a", obj.Field1)
|
||||
should.Equal("b", obj.Field2)
|
||||
should.Equal("stream", obj.Field2)
|
||||
should.Equal("c", obj.Field3)
|
||||
should.Equal("d", obj.Field4)
|
||||
should.Equal("e", obj.Field5)
|
||||
|
||||
@ -9,90 +9,90 @@ import (
|
||||
)
|
||||
|
||||
func Test_skip_number(t *testing.T) {
|
||||
iter := ParseString(ConfigDefault, `[-0.12, "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[-0.12, "stream"]`)
|
||||
iter.ReadArray()
|
||||
iter.Skip()
|
||||
iter.ReadArray()
|
||||
if iter.ReadString() != "b" {
|
||||
if iter.ReadString() != "stream" {
|
||||
t.FailNow()
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func Test_skip_null(t *testing.T) {
|
||||
iter := ParseString(ConfigDefault, `[null , "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[null , "stream"]`)
|
||||
iter.ReadArray()
|
||||
iter.Skip()
|
||||
iter.ReadArray()
|
||||
if iter.ReadString() != "b" {
|
||||
if iter.ReadString() != "stream" {
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
func Test_skip_true(t *testing.T) {
|
||||
iter := ParseString(ConfigDefault, `[true , "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[true , "stream"]`)
|
||||
iter.ReadArray()
|
||||
iter.Skip()
|
||||
iter.ReadArray()
|
||||
if iter.ReadString() != "b" {
|
||||
if iter.ReadString() != "stream" {
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
func Test_skip_false(t *testing.T) {
|
||||
iter := ParseString(ConfigDefault, `[false , "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[false , "stream"]`)
|
||||
iter.ReadArray()
|
||||
iter.Skip()
|
||||
iter.ReadArray()
|
||||
if iter.ReadString() != "b" {
|
||||
if iter.ReadString() != "stream" {
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
func Test_skip_array(t *testing.T) {
|
||||
iter := ParseString(ConfigDefault, `[[1, [2, [3], 4]], "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[[1, [2, [3], 4]], "stream"]`)
|
||||
iter.ReadArray()
|
||||
iter.Skip()
|
||||
iter.ReadArray()
|
||||
if iter.ReadString() != "b" {
|
||||
if iter.ReadString() != "stream" {
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
func Test_skip_empty_array(t *testing.T) {
|
||||
iter := ParseString(ConfigDefault, `[ [ ], "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[ [ ], "stream"]`)
|
||||
iter.ReadArray()
|
||||
iter.Skip()
|
||||
iter.ReadArray()
|
||||
if iter.ReadString() != "b" {
|
||||
if iter.ReadString() != "stream" {
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
func Test_skip_nested(t *testing.T) {
|
||||
iter := ParseString(ConfigDefault, `[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
|
||||
iter.ReadArray()
|
||||
iter.Skip()
|
||||
iter.ReadArray()
|
||||
if iter.ReadString() != "b" {
|
||||
if iter.ReadString() != "stream" {
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
func Test_skip_and_return_bytes(t *testing.T) {
|
||||
should := require.New(t)
|
||||
iter := ParseString(ConfigDefault, `[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
|
||||
iter := ParseString(ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
|
||||
iter.ReadArray()
|
||||
skipped := iter.SkipAndReturnBytes()
|
||||
should.Equal(`{"a" : [{"b": "c"}], "d": 102 }`, string(skipped))
|
||||
should.Equal(`{"a" : [{"stream": "c"}], "d": 102 }`, string(skipped))
|
||||
}
|
||||
|
||||
func Test_skip_and_return_bytes_with_reader(t *testing.T) {
|
||||
should := require.New(t)
|
||||
iter := Parse(ConfigDefault, bytes.NewBufferString(`[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`), 4)
|
||||
iter := Parse(ConfigDefault, bytes.NewBufferString(`[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`), 4)
|
||||
iter.ReadArray()
|
||||
skipped := iter.SkipAndReturnBytes()
|
||||
should.Equal(`{"a" : [{"b": "c"}], "d": 102 }`, string(skipped))
|
||||
should.Equal(`{"a" : [{"stream": "c"}], "d": 102 }`, string(skipped))
|
||||
}
|
||||
|
||||
type TestResp struct {
|
||||
|
||||
@ -46,7 +46,7 @@ func (m *marshalerForTest) UnmarshalJSON(text []byte) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
var _ json.Marshaler = Marshaler{}
|
||||
var _ json.Unmarshaler = &Marshaler{}
|
||||
var _ json.Marshaler = marshalerForTest{}
|
||||
var _ json.Unmarshaler = &marshalerForTest{}
|
||||
|
||||
type typeForTest marshalerForTest
|
||||
|
||||
@ -46,11 +46,11 @@ func (m *marshalerForTest) UnmarshalJSON(text []byte) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
var _ json.Marshaler = Marshaler{}
|
||||
var _ json.Unmarshaler = &Marshaler{}
|
||||
var _ json.Marshaler = marshalerForTest{}
|
||||
var _ json.Unmarshaler = &marshalerForTest{}
|
||||
|
||||
type typeForTest struct {
|
||||
S string
|
||||
M Marshaler
|
||||
M marshalerForTest
|
||||
I int8
|
||||
}
|
||||
|
||||
@ -7,7 +7,8 @@ import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
type marshalerForTest string
|
||||
// MarshalerForTest TEST ONLY
|
||||
type MarshalerForTest string
|
||||
|
||||
func encode(str string) string {
|
||||
buf := bytes.Buffer{}
|
||||
@ -35,20 +36,20 @@ func decode(str string) string {
|
||||
return string(bs)
|
||||
}
|
||||
|
||||
func (m marshalerForTest) MarshalJSON() ([]byte, error) {
|
||||
func (m MarshalerForTest) MarshalJSON() ([]byte, error) {
|
||||
return []byte(`"MANUAL__` + encode(string(m)) + `"`), nil
|
||||
}
|
||||
|
||||
func (m *marshalerForTest) UnmarshalJSON(text []byte) error {
|
||||
*m = marshalerForTest(decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")))
|
||||
func (m *MarshalerForTest) UnmarshalJSON(text []byte) error {
|
||||
*m = MarshalerForTest(decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")))
|
||||
return nil
|
||||
}
|
||||
|
||||
var _ json.Marshaler = *new(marshalerForTest)
|
||||
var _ json.Unmarshaler = new(marshalerForTest)
|
||||
var _ json.Marshaler = *new(MarshalerForTest)
|
||||
var _ json.Unmarshaler = new(MarshalerForTest)
|
||||
|
||||
type typeForTest struct {
|
||||
F1 float64
|
||||
Marshaler
|
||||
MarshalerForTest
|
||||
F2 int32
|
||||
}
|
||||
|
||||
@ -7,7 +7,8 @@ import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
type marshalerForTest string
|
||||
// MarshalerForTest TEST ONLY
|
||||
type MarshalerForTest string
|
||||
|
||||
func encode(str string) string {
|
||||
buf := bytes.Buffer{}
|
||||
@ -35,20 +36,20 @@ func decode(str string) string {
|
||||
return string(bs)
|
||||
}
|
||||
|
||||
func (m marshalerForTest) MarshalText() ([]byte, error) {
|
||||
func (m MarshalerForTest) MarshalText() ([]byte, error) {
|
||||
return []byte(`MANUAL__` + encode(string(m))), nil
|
||||
}
|
||||
|
||||
func (m *marshalerForTest) UnmarshalText(text []byte) error {
|
||||
*m = marshalerForTest(decode(strings.TrimPrefix(string(text), "MANUAL__")))
|
||||
func (m *MarshalerForTest) UnmarshalText(text []byte) error {
|
||||
*m = MarshalerForTest(decode(strings.TrimPrefix(string(text), "MANUAL__")))
|
||||
return nil
|
||||
}
|
||||
|
||||
var _ encoding.TextMarshaler = *new(marshalerForTest)
|
||||
var _ encoding.TextUnmarshaler = new(marshalerForTest)
|
||||
var _ encoding.TextMarshaler = *new(MarshalerForTest)
|
||||
var _ encoding.TextUnmarshaler = new(MarshalerForTest)
|
||||
|
||||
type typeForTest struct {
|
||||
F1 float64
|
||||
Marshaler
|
||||
MarshalerForTest
|
||||
F2 int32
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user