package serial
import (
"io"
"reflect"
"strconv"
"strings"
"sync"
)
type Encoder struct {
w io.Writer
wg sync.WaitGroup
groups []string
}
func (e *Encoder) Encode(entity interface{}) error {
t := reflect.TypeOf(entity)
v := reflect.ValueOf(entity)
if err := e.encodeField(t, v, e.w); err != nil {
return err
}
return nil
}
func (e *Encoder) encodeAny(entity interface{}, w io.Writer) error {
t := reflect.TypeOf(entity)
v := reflect.ValueOf(entity)
first := true
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
fv := v.Field(i)
if gr, ok := f.Tag.Lookup("group"); ok {
groups := strings.Split(gr, ",")
name := f.Name
if tname, ok := f.Tag.Lookup("json"); ok {
name = tname
}
if name != "-" && e.intersect(groups, e.groups) {
if !first {
w.Write([]byte(`,`))
}
w.Write([]byte(`"` + name + `":`))
e.encodeField(f.Type, fv, w)
first = false
}
}
}
return nil
}
func (e *Encoder) intersect(a []string, b []string) bool {
for _, sa := range a {
for _, sb := range b {
if sa == sb {
return true
}
}
}
return false
}
func (e *Encoder) encodeField(ft reflect.Type, v reflect.Value, w io.Writer) error {
switch ft.Kind() {
case reflect.Struct:
w.Write([]byte("{"))
if err := e.encodeAny(v.Interface(), w); err != nil {
return err
}
w.Write([]byte("}"))
case reflect.String:
w.Write([]byte(`"` + v.String() + `"`))
case reflect.Bool:
if v.Bool() {
w.Write([]byte("true"))
} else {
w.Write([]byte("false"))
}
case reflect.Int, reflect.Int32, reflect.Int64:
w.Write([]byte(strconv.Itoa(int(v.Int()))))
case reflect.Float32, reflect.Float64:
w.Write([]byte(strconv.FormatFloat(v.Float(), 'f', -1, 64)))
}
return nil
}
func (e *Encoder) AddGroup(group string) *Encoder {
e.groups = append(e.groups, group)
return e
}
func NewEncoder(w io.Writer) *Encoder {
return &Encoder{w: w, groups: []string{}}
}
