Skip to content

Commit

Permalink
Support encoding of slice
Browse files Browse the repository at this point in the history
  • Loading branch information
@goccy
goccy committed Apr 19, 2020
1 parent 61c8bdb commit 3e814f7
Show file tree
Hide file tree
Showing 2 changed files with 211 additions and 13 deletions.
62 changes: 49 additions & 13 deletions encode.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -117,36 +117,42 @@ func (e *Encoder) EncodeByte(b byte) {
func (e *Encoder) Encode(v interface{}) ([]byte, error) {
rv := reflect.ValueOf(v)
if rv.Kind() != reflect.Ptr {
rv = rv.Addr()
newV := reflect.New(rv.Type())
newV.Elem().Set(rv)
rv = newV
}
return e.encode(rv)
}

func (e *Encoder) encode(v reflect.Value) ([]byte, error) {
name := v.Type().Name()
name := v.Type().String()
if op, exists := cachedEncodeOp[name]; exists {
op(e, v.Pointer())
copied := make([]byte, len(e.buf))
copy(copied, e.buf)
return copied, nil
}
op, err := e.compile(v)
op, err := e.compile(v.Type())
if err != nil {
return nil, err
}
cachedEncodeOp[name] = op
if name != "" {
cachedEncodeOp[name] = op
}
op(e, v.Pointer())
copied := make([]byte, len(e.buf))
copy(copied, e.buf)
return copied, nil
}

func (e *Encoder) compile(v reflect.Value) (EncodeOp, error) {
switch v.Type().Kind() {
func (e *Encoder) compile(typ reflect.Type) (EncodeOp, error) {
switch typ.Kind() {
case reflect.Ptr:
return e.compile(v.Elem())
return e.compile(typ.Elem())
case reflect.Slice:
return e.compileSlice(typ)
case reflect.Struct:
return e.compileStruct(v)
return e.compileStruct(typ)
case reflect.Int:
return e.compileInt()
case reflect.Int8:
Expand All @@ -157,6 +163,16 @@ func (e *Encoder) compile(v reflect.Value) (EncodeOp, error) {
return e.compileInt32()
case reflect.Int64:
return e.compileInt64()
case reflect.Uint:
return e.compileUint()
case reflect.Uint8:
return e.compileUint8()
case reflect.Uint16:
return e.compileUint16()
case reflect.Uint32:
return e.compileUint32()
case reflect.Uint64:
return e.compileUint64()
case reflect.Float32:
return e.compileFloat32()
case reflect.Float64:
Expand All @@ -166,7 +182,7 @@ func (e *Encoder) compile(v reflect.Value) (EncodeOp, error) {
case reflect.Bool:
return e.compileBool()
}
return nil, xerrors.Errorf("failed to compile %s: %w", v.Type(), ErrUnknownType)
return nil, xerrors.Errorf("failed to compile %s: %w", typ, ErrUnknownType)
}

func (e *Encoder) compileInt() (EncodeOp, error) {
Expand Down Expand Up @@ -225,9 +241,29 @@ func (e *Encoder) compileBool() (EncodeOp, error) {
return func(enc *Encoder, p uintptr) { enc.EncodeBool(e.ptrToBool(p)) }, nil
}

func (e *Encoder) compileStruct(v reflect.Value) (EncodeOp, error) {
typ := v.Type()
fieldNum := v.NumField()
func (e *Encoder) compileSlice(typ reflect.Type) (EncodeOp, error) {
size := typ.Elem().Size()
op, err := e.compile(typ.Elem())
if err != nil {
return nil, err
}
return func(enc *Encoder, base uintptr) {
enc.EncodeByte('[')
slice := (*reflect.SliceHeader)(unsafe.Pointer(base))
num := slice.Len
for i := 0; i < num; i++ {
op(enc, slice.Data+uintptr(i)*size)
if i != num-1 {
enc.EncodeByte(',')
}
}
enc.EncodeByte(']')
}, nil

}

func (e *Encoder) compileStruct(typ reflect.Type) (EncodeOp, error) {
fieldNum := typ.NumField()
opQueue := make([]EncodeOp, 0, fieldNum)
for i := 0; i < fieldNum; i++ {
field := typ.Field(i)
Expand All @@ -239,7 +275,7 @@ func (e *Encoder) compileStruct(v reflect.Value) (EncodeOp, error) {
keyName = opts[0]
}
}
op, err := e.compile(v.Field(i))
op, err := e.compile(typ.Field(i).Type)
if err != nil {
return nil, err
}
Expand Down
162 changes: 162 additions & 0 deletions encode_test.go
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,162 @@
package json_test

import (
"testing"

"github.com/goccy/go-json"
)

func Test_Encoder(t *testing.T) {
t.Run("int", func(t *testing.T) {
bytes, err := json.Marshal(-10)
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `-10` {
t.Fatal("failed to encode int")
}
})
t.Run("int8", func(t *testing.T) {
bytes, err := json.Marshal(int8(-11))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `-11` {
t.Fatal("failed to encode int8")
}
})
t.Run("int16", func(t *testing.T) {
bytes, err := json.Marshal(int16(-12))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `-12` {
t.Fatal("failed to encode int16")
}
})
t.Run("int32", func(t *testing.T) {
bytes, err := json.Marshal(int32(-13))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `-13` {
t.Fatal("failed to encode int32")
}
})
t.Run("int64", func(t *testing.T) {
bytes, err := json.Marshal(int64(-14))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `-14` {
t.Fatal("failed to encode int64")
}
})
t.Run("uint", func(t *testing.T) {
bytes, err := json.Marshal(uint(10))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `10` {
t.Fatal("failed to encode uint")
}
})
t.Run("uint8", func(t *testing.T) {
bytes, err := json.Marshal(uint8(11))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `11` {
t.Fatal("failed to encode uint8")
}
})
t.Run("uint16", func(t *testing.T) {
bytes, err := json.Marshal(uint16(12))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `12` {
t.Fatal("failed to encode uint16")
}
})
t.Run("uint32", func(t *testing.T) {
bytes, err := json.Marshal(uint32(13))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `13` {
t.Fatal("failed to encode uint32")
}
})
t.Run("uint64", func(t *testing.T) {
bytes, err := json.Marshal(uint64(14))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `14` {
t.Fatal("failed to encode uint64")
}
})
t.Run("float32", func(t *testing.T) {
bytes, err := json.Marshal(float32(3.14))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `3.14` {
t.Fatal("failed to encode float32")
}
})
t.Run("float64", func(t *testing.T) {
bytes, err := json.Marshal(float64(3.14))
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `3.14` {
t.Fatal("failed to encode float64")
}
})
t.Run("bool", func(t *testing.T) {
bytes, err := json.Marshal(true)
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `true` {
t.Fatal("failed to encode bool")
}
})
t.Run("string", func(t *testing.T) {
bytes, err := json.Marshal("hello world")
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `"hello world"` {
t.Fatal("failed to encode string")
}
})
t.Run("struct", func(t *testing.T) {
bytes, err := json.Marshal(struct {
A int `json:"a"`
B uint `json:"b"`
C string `json:"c"`
}{
A: -1,
B: 1,
C: "hello world",
})
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `{"a":-1,"b":1,"c":"hello world"}` {
t.Fatal("failed to encode struct")
}
})
t.Run("slice", func(t *testing.T) {
bytes, err := json.Marshal([]int{1, 2, 3, 4})
if err != nil {
t.Fatalf("%+v", err)
}
if string(bytes) != `[1,2,3,4]` {
t.Fatal("failed to encode slice of int")
}
})
}

0 comments on commit 3e814f7

Please sign in to comment.