134 lines
2.0 KiB
Go
134 lines
2.0 KiB
Go
package util
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
)
|
|
|
|
var ErrDecode = errors.New("decode")
|
|
|
|
type Encoder struct {
|
|
b []byte
|
|
err error
|
|
}
|
|
|
|
func NewEncoder(dst []byte) *Encoder { return &Encoder{b: dst} }
|
|
func (e *Encoder) Bytes() []byte { return e.b }
|
|
func (e *Encoder) Err() error { return e.err }
|
|
|
|
func (e *Encoder) U8(v uint8) {
|
|
if e.err != nil {
|
|
return
|
|
}
|
|
e.b = append(e.b, v)
|
|
}
|
|
|
|
func (e *Encoder) U32(v uint32) {
|
|
if e.err != nil {
|
|
return
|
|
}
|
|
var tmp [4]byte
|
|
binary.LittleEndian.PutUint32(tmp[:], v)
|
|
e.b = append(e.b, tmp[:]...)
|
|
}
|
|
|
|
func (e *Encoder) BytesFixed(p []byte) {
|
|
if e.err != nil {
|
|
return
|
|
}
|
|
e.b = append(e.b, p...)
|
|
}
|
|
|
|
func (e *Encoder) BytesLen(p []byte) {
|
|
if e.err != nil {
|
|
return
|
|
}
|
|
e.U32(uint32(len(p)))
|
|
e.b = append(e.b, p...)
|
|
}
|
|
|
|
func (e *Encoder) String(s string) {
|
|
e.BytesLen([]byte(s))
|
|
}
|
|
|
|
func (e *Encoder) StringSlice(ss []string) {
|
|
if e.err != nil {
|
|
return
|
|
}
|
|
e.U32(uint32(len(ss)))
|
|
for _, s := range ss {
|
|
e.String(s)
|
|
}
|
|
}
|
|
|
|
type Decoder struct {
|
|
b []byte
|
|
off int
|
|
err error
|
|
}
|
|
|
|
func NewDecoder(src []byte) *Decoder { return &Decoder{b: src} }
|
|
func (d *Decoder) Err() error { return d.err }
|
|
|
|
func (d *Decoder) need(n int) bool {
|
|
if d.err != nil {
|
|
return false
|
|
}
|
|
if n < 0 || d.off+n > len(d.b) {
|
|
d.err = ErrDecode
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (d *Decoder) U8() uint8 {
|
|
if !d.need(1) {
|
|
return 0
|
|
}
|
|
v := d.b[d.off]
|
|
d.off++
|
|
return v
|
|
}
|
|
|
|
func (d *Decoder) U32() uint32 {
|
|
if !d.need(4) {
|
|
return 0
|
|
}
|
|
v := binary.LittleEndian.Uint32(d.b[d.off : d.off+4])
|
|
d.off += 4
|
|
return v
|
|
}
|
|
|
|
func (d *Decoder) BytesFixed(n int) []byte {
|
|
if !d.need(n) {
|
|
return nil
|
|
}
|
|
out := d.b[d.off : d.off+n]
|
|
d.off += n
|
|
return out
|
|
}
|
|
|
|
func (d *Decoder) BytesLen() []byte {
|
|
n := int(d.U32())
|
|
return d.BytesFixed(n)
|
|
}
|
|
|
|
func (d *Decoder) String() string {
|
|
return string(d.BytesLen())
|
|
}
|
|
|
|
func (d *Decoder) StringSlice() []string {
|
|
n := int(d.U32())
|
|
if d.Err() != nil {
|
|
return nil
|
|
}
|
|
out := make([]string, 0, n)
|
|
for range n {
|
|
out = append(out, d.String())
|
|
if d.Err() != nil {
|
|
return nil
|
|
}
|
|
}
|
|
return out
|
|
}
|