reset decoder when decoding is done to enable reuse of decoder

benchmarks/decoder/decoder_bench_large_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/mailru/easyjson"
 )
 
-func BenchmarkJsonParserDecodeObjLarge(b *testing.B) {
+func BenchmarkJSONParserDecodeObjLarge(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		jsonparser.ArrayEach(benchmarks.LargeFixture, func(value []byte, dataType jsonparser.ValueType, offset int, err error) {
@@ -26,15 +26,15 @@ func BenchmarkJsonParserDecodeObjLarge(b *testing.B) {
 	}
 }
 
-func BenchmarkJsonIterDecodeObjLarge(b *testing.B) {
+func BenchmarkJSONIterDecodeObjLarge(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		result := benchmarks.LargePayload{}
 		jsoniter.Unmarshal(benchmarks.LargeFixture, &result)
 	}
 }
 
-func BenchmarkEasyJsonDecodeObjLarge(b *testing.B) {
+func BenchmarkEasyJSONDecodeObjLarge(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		result := benchmarks.LargePayload{}

benchmarks/decoder/decoder_bench_medium_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/mailru/easyjson"
 )
 
-func BenchmarkJsonIterDecodeObjMedium(b *testing.B) {
+func BenchmarkJSONIterDecodeObjMedium(b *testing.B) {
 	b.ReportAllocs()
 	for n := 0; n < b.N; n++ {
 		result := benchmarks.MediumPayload{}
@@ -36,14 +36,14 @@ func BenchmarkJSONParserDecodeObjMedium(b *testing.B) {
 	}
 }
 
-func BenchmarkEncodingJsonStructMedium(b *testing.B) {
+func BenchmarkEncodingJSONDecodeObjMedium(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		var data = benchmarks.MediumPayload{}
 		json.Unmarshal(benchmarks.MediumFixture, &data)
 	}
 }
 
-func BenchmarkEasyJsonDecodeObjMedium(b *testing.B) {
+func BenchmarkEasyJSONDecodeObjMedium(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		result := benchmarks.MediumPayload{}

benchmarks/decoder/decoder_bench_small_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/mailru/easyjson"
 )
 
-func BenchmarkJSONDecodeObjSmall(b *testing.B) {
+func BenchmarkEncodingJSONDecodeObjSmall(b *testing.B) {
 	b.ReportAllocs()
 	for n := 0; n < b.N; n++ {
 		result := benchmarks.SmallPayload{}
@@ -36,15 +36,15 @@ func BenchmarkJSONParserSmall(b *testing.B) {
 	}
 }
 
-func BenchmarkJsonIterDecodeObjSmall(b *testing.B) {
+func BenchmarkJSONIterDecodeObjSmall(b *testing.B) {
 	b.ReportAllocs()
 	for n := 0; n < b.N; n++ {
 		result := benchmarks.SmallPayload{}
 		jsoniter.Unmarshal(benchmarks.SmallFixture, &result)
 	}
 }
 
-func BenchmarkEasyJsonDecodeObjSmall(b *testing.B) {
+func BenchmarkEasyJSONDecodeObjSmall(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		result := benchmarks.SmallPayload{}

decode.go

@@ -13,17 +13,22 @@ import (
 // overflows the target type, UnmarshalJSONArray skips that field and completes the unmarshaling as best it can.
 func UnmarshalJSONArray(data []byte, v UnmarshalerJSONArray) error {
 	dec := borrowDecoder(nil, 0)
+
 	defer dec.Release()
+
 	dec.data = make([]byte, len(data))
 	copy(dec.data, data)
 	dec.length = len(data)
+
 	_, err := dec.decodeArray(v)
 	if err != nil {
 		return err
 	}
+
 	if dec.err != nil {
 		return dec.err
 	}
+
 	return nil
 }
 
@@ -35,14 +40,18 @@ func UnmarshalJSONArray(data []byte, v UnmarshalerJSONArray) error {
 // overflows the target type, UnmarshalJSONObject skips that field and completes the unmarshaling as best it can.
 func UnmarshalJSONObject(data []byte, v UnmarshalerJSONObject) error {
 	dec := borrowDecoder(nil, 0)
+
 	defer dec.Release()
+
 	dec.data = make([]byte, len(data))
 	copy(dec.data, data)
 	dec.length = len(data)
+
 	_, err := dec.decodeObject(v)
 	if err != nil {
 		return err
 	}
+
 	if dec.err != nil {
 		return dec.err
 	}
@@ -215,11 +224,14 @@ func Unmarshal(data []byte, v interface{}) error {
 	default:
 		return InvalidUnmarshalError(fmt.Sprintf(invalidUnmarshalErrorMsg, vt))
 	}
-	defer dec.Release()
-	if err != nil {
-		return err
+
+	if err == nil {
+		err = dec.err
 	}
-	return dec.err
+
+	dec.Release()
+
+	return err
 }
 
 // UnmarshalerJSONObject is the interface to implement to decode a JSON Object.
@@ -257,7 +269,9 @@ func (dec *Decoder) Decode(v interface{}) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
+
 	var err error
+
 	switch vt := v.(type) {
 	case *string:
 		err = dec.decodeString(vt)
@@ -312,20 +326,24 @@ func (dec *Decoder) Decode(v interface{}) error {
 	case **bool:
 		err = dec.decodeBoolNull(vt)
 	case UnmarshalerJSONObject:
-		_, err = dec.decodeObject(vt)
+		dec.cursor, err = dec.decodeObject(vt)
 	case UnmarshalerJSONArray:
-		_, err = dec.decodeArray(vt)
+		dec.cursor, err = dec.decodeArray(vt)
 	case *EmbeddedJSON:
 		err = dec.decodeEmbeddedJSON(vt)
 	case *interface{}:
 		err = dec.decodeInterface(vt)
 	default:
 		return InvalidUnmarshalError(fmt.Sprintf(invalidUnmarshalErrorMsg, vt))
 	}
-	if err != nil {
-		return err
+
+	if err == nil {
+		err = dec.err
 	}
-	return dec.err
+
+	dec.reset()
+
+	return err
 }
 
 // Non exported

decode_array.go

@@ -12,7 +12,12 @@ func (dec *Decoder) DecodeArray(v UnmarshalerJSONArray) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	_, err := dec.decodeArray(v)
+
+	var err error
+	dec.cursor, err = dec.decodeArray(v)
+
+	dec.reset()
+
 	return err
 }
 func (dec *Decoder) decodeArray(arr UnmarshalerJSONArray) (int, error) {

decode_bool.go

@@ -8,7 +8,11 @@ func (dec *Decoder) DecodeBool(v *bool) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeBool(v)
+
+	err := dec.decodeBool(v)
+	dec.reset()
+
+	return err
 }
 func (dec *Decoder) decodeBool(v *bool) error {
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {

decode_bool_test.go

@@ -489,6 +489,7 @@ func TestDecoderBoolDecoderAPI(t *testing.T) {
 func TestDecoderBoolPoolError(t *testing.T) {
 	v := true
 	dec := NewDecoder(nil)
+	dec.reset()
 	dec.Release()
 	defer func() {
 		err := recover()

decode_embedded_json_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type Request struct {
@@ -178,3 +179,26 @@ func TestDecodeEmbeededJSONNil2(t *testing.T) {
 	assert.NotNil(t, err, `err should not be nil a nil pointer is given`)
 	assert.IsType(t, InvalidUnmarshalError(""), err, `err should not be of type InvalidUnmarshalError`)
 }
+
+func TestDecoderReuse(t *testing.T) {
+	r := strings.NewReader(`{"foo":"bar"}{"foo":"baz"}{"foo":"world"}`)
+
+	dec := NewDecoder(r)
+	var ej EmbeddedJSON
+
+	dec.Decode(&ej)
+
+	require.Equal(t, `{"foo":"bar"}`, string(ej))
+
+	ej = ej[:0]
+
+	dec.Decode(&ej)
+
+	assert.Equal(t, `{"foo":"baz"}`, string(ej))
+
+	ej = ej[:0]
+
+	dec.Decode(&ej)
+
+	assert.Equal(t, `{"foo":"world"}`, string(ej))
+}

decode_interface.go

@@ -11,7 +11,10 @@ func (dec *Decoder) DecodeInterface(i *interface{}) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
+
 	err := dec.decodeInterface(i)
+	dec.reset()
+
 	return err
 }
 

decode_interface_test.go

@@ -511,6 +511,7 @@ func TestUnmarshalInterfaceError(t *testing.T) {
 func TestDecodeInterfacePoolError(t *testing.T) {
 	result := interface{}(1)
 	dec := NewDecoder(nil)
+	dec.reset()
 	dec.Release()
 	defer func() {
 		err := recover()

decode_number_float.go

@@ -7,7 +7,11 @@ func (dec *Decoder) DecodeFloat64(v *float64) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeFloat64(v)
+
+	err := dec.decodeFloat64(v)
+	dec.reset()
+
+	return err
 }
 func (dec *Decoder) decodeFloat64(v *float64) error {
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
@@ -215,7 +219,11 @@ func (dec *Decoder) DecodeFloat32(v *float32) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeFloat32(v)
+
+	err := dec.decodeFloat32(v)
+	dec.reset()
+
+	return err
 }
 func (dec *Decoder) decodeFloat32(v *float32) error {
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {

decode_number_float_test.go

@@ -298,6 +298,7 @@ func TestDecoderFloat64(t *testing.T) {
 	t.Run("pool-error", func(t *testing.T) {
 		result := float64(1)
 		dec := NewDecoder(nil)
+		dec.reset()
 		dec.Release()
 		defer func() {
 			err := recover()
@@ -931,6 +932,7 @@ func TestDecoderFloat32(t *testing.T) {
 	t.Run("pool-error", func(t *testing.T) {
 		result := float32(1)
 		dec := NewDecoder(nil)
+		dec.reset()
 		dec.Release()
 		defer func() {
 			err := recover()

decode_number_int.go

@@ -12,7 +12,11 @@ func (dec *Decoder) DecodeInt(v *int) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeInt(v)
+
+	err := dec.decodeInt(v)
+	dec.reset()
+
+	return err
 }
 func (dec *Decoder) decodeInt(v *int) error {
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
@@ -119,7 +123,11 @@ func (dec *Decoder) DecodeInt16(v *int16) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeInt16(v)
+
+	err := dec.decodeInt16(v)
+	dec.reset()
+
+	return err
 }
 func (dec *Decoder) decodeInt16(v *int16) error {
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
@@ -351,7 +359,11 @@ func (dec *Decoder) DecodeInt8(v *int8) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeInt8(v)
+
+	err := dec.decodeInt8(v)
+	dec.reset()
+
+	return err
 }
 func (dec *Decoder) decodeInt8(v *int8) error {
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
@@ -582,7 +594,11 @@ func (dec *Decoder) DecodeInt32(v *int32) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeInt32(v)
+
+	err := dec.decodeInt32(v)
+	dec.reset()
+
+	return err
 }
 func (dec *Decoder) decodeInt32(v *int32) error {
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
@@ -812,7 +828,11 @@ func (dec *Decoder) DecodeInt64(v *int64) error {
 	if dec.isPooled == 1 {
 		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
 	}
-	return dec.decodeInt64(v)
+
+	err := dec.decodeInt64(v)
+	dec.reset()
+
+	return err
 }
 
 func (dec *Decoder) decodeInt64(v *int64) error {