gojay

commit 240dc285cc79fe1c60953cf109b32a9121d6f8fb
parent 820044ef83b5f70f7bedd63b2c1bdbe6b30c848e
Author: francoispqt <francois@parquet.ninja>
Date:   Mon,  7 May 2018 21:15:32 +0800

add-int64-funcs

Diffstat:
M
encode_number.go
 | 
24
++++++++++++++++++++++++
M
encode_number_test.go
 | 
56
+++++++++++++++++++++++++++++++++++++++++++++++++++-----

2 files changed, 75 insertions(+), 5 deletions(-)
diff --git a/encode_number.go b/encode_number.go
@@ -101,6 +101,30 @@ func (enc *Encoder) AddIntOmitEmpty(v int) {
 	enc.buf = strconv.AppendInt(enc.buf, int64(v), 10)
 }
 
+// AddInt64 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)
+func (enc *Encoder) AddInt64(v int64) {
+	enc.grow(10)
+	r := enc.getPreviousRune()
+	if r != '[' {
+		enc.writeByte(',')
+	}
+	enc.buf = strconv.AppendInt(enc.buf, v, 10)
+}
+
+// AddIntOmitEmpty adds an int to be encoded and skips it if its value is 0,
+// must be used inside a slice or array encoding (does not encode a key).
+func (enc *Encoder) AddInt64OmitEmpty(v int64) {
+	if v == 0 {
+		return
+	}
+	enc.grow(10)
+	r := enc.getPreviousRune()
+	if r != '[' {
+		enc.writeByte(',')
+	}
+	enc.buf = strconv.AppendInt(enc.buf, v, 10)
+}
+
 // AddFloat adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)
 func (enc *Encoder) AddFloat(v float64) {
 	enc.grow(10)
diff --git a/encode_number_test.go b/encode_number_test.go
@@ -229,7 +229,7 @@ func TestEncoderNumberMarshalAPI(t *testing.T) {
 }
 
 func TestAddNumberFunc(t *testing.T) {
-	t.Run("int64", func(t *testing.T) {
+	t.Run("int64-key", func(t *testing.T) {
 		builder := &strings.Builder{}
 		enc := BorrowEncoder(builder)
 		enc.writeByte('{')
@@ -238,7 +238,7 @@ func TestAddNumberFunc(t *testing.T) {
 		assert.Nil(t, err, "err should be nil")
 		assert.Equal(t, `{"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`)
 	})
-	t.Run("int64-2", func(t *testing.T) {
+	t.Run("int64-key-2", func(t *testing.T) {
 		builder := &strings.Builder{}
 		enc := BorrowEncoder(builder)
 		enc.writeBytes([]byte(`{"test":1`))
@@ -248,7 +248,7 @@ func TestAddNumberFunc(t *testing.T) {
 		assert.Equal(t, `{"test":1,"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`)
 	})
 
-	t.Run("int64-omit-empty", func(t *testing.T) {
+	t.Run("int64-key-omit-empty", func(t *testing.T) {
 		builder := &strings.Builder{}
 		enc := BorrowEncoder(builder)
 		enc.writeByte('{')
@@ -257,7 +257,7 @@ func TestAddNumberFunc(t *testing.T) {
 		assert.Nil(t, err, "err should be nil")
 		assert.Equal(t, `{"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`)
 	})
-	t.Run("int64-omit-empty-2", func(t *testing.T) {
+	t.Run("int64-key-omit-empty-2", func(t *testing.T) {
 		builder := &strings.Builder{}
 		enc := BorrowEncoder(builder)
 		enc.writeBytes([]byte(`{"test":1`))
@@ -266,7 +266,7 @@ func TestAddNumberFunc(t *testing.T) {
 		assert.Nil(t, err, "err should be nil")
 		assert.Equal(t, `{"test":1,"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`)
 	})
-	t.Run("int64-omit-empty-3", func(t *testing.T) {
+	t.Run("int64-key-omit-empty-3", func(t *testing.T) {
 		builder := &strings.Builder{}
 		enc := BorrowEncoder(builder)
 		enc.writeByte('{')
@@ -275,4 +275,50 @@ func TestAddNumberFunc(t *testing.T) {
 		assert.Nil(t, err, "err should be nil")
 		assert.Equal(t, `{`, builder.String(), `builder.String() should be equal to {"test":10"`)
 	})
+	t.Run("int64", func(t *testing.T) {
+		builder := &strings.Builder{}
+		enc := BorrowEncoder(builder)
+		enc.writeByte('[')
+		enc.AddInt64(10)
+		_, err := enc.Write()
+		assert.Nil(t, err, "err should be nil")
+		assert.Equal(t, `[10`, builder.String(), `builder.String() should be equal to {"test":10"`)
+	})
+	t.Run("int64-2", func(t *testing.T) {
+		builder := &strings.Builder{}
+		enc := BorrowEncoder(builder)
+		enc.writeBytes([]byte(`[1`))
+		enc.AddInt64(10)
+		_, err := enc.Write()
+		assert.Nil(t, err, "err should be nil")
+		assert.Equal(t, `[1,10`, builder.String(), `builder.String() should be equal to {"test":10"`)
+	})
+
+	t.Run("int64-omit-empty", func(t *testing.T) {
+		builder := &strings.Builder{}
+		enc := BorrowEncoder(builder)
+		enc.writeByte('[')
+		enc.AddInt64OmitEmpty(10)
+		_, err := enc.Write()
+		assert.Nil(t, err, "err should be nil")
+		assert.Equal(t, `[10`, builder.String(), `builder.String() should be equal to {"test":10"`)
+	})
+	t.Run("int64-omit-empty-2", func(t *testing.T) {
+		builder := &strings.Builder{}
+		enc := BorrowEncoder(builder)
+		enc.writeBytes([]byte(`[1`))
+		enc.AddInt64OmitEmpty(10)
+		_, err := enc.Write()
+		assert.Nil(t, err, "err should be nil")
+		assert.Equal(t, `[1,10`, builder.String(), `builder.String() should be equal to {"test":10"`)
+	})
+	t.Run("int64-omit-empty-3", func(t *testing.T) {
+		builder := &strings.Builder{}
+		enc := BorrowEncoder(builder)
+		enc.writeByte('[')
+		enc.AddInt64OmitEmpty(0)
+		_, err := enc.Write()
+		assert.Nil(t, err, "err should be nil")
+		assert.Equal(t, `[`, builder.String(), `builder.String() should be equal to {"test":10"`)
+	})
 }