Additions to domain/ and workspace/ chron-note packages

chron-note/internal/util/encoding.go

@@ -1 +1,133 @@
 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
+}