json: Implement a bunch of streaming JSON encoding/decoding

4 files changed, 160 insertions, 0 deletions

diff --git a/lib/btrfs/btrfsitem/item_extentcsum.go b/lib/btrfs/btrfsitem/item_extentcsum.go
index b35d333..eedd044 100644
--- a/lib/btrfs/btrfsitem/item_extentcsum.go
+++ b/lib/btrfs/btrfsitem/item_extentcsum.go
@@ -5,7 +5,11 @@
 package btrfsitem
 
 import (
+	"encoding/hex"
 	"fmt"
+	"io"
+
+	"git.lukeshu.com/go/lowmemjson"
 
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfssum"
 )
@@ -43,3 +47,33 @@ func (o ExtentCSum) MarshalBinary() ([]byte, error) {
 	}
 	return dat, nil
 }
+
+var (
+	_ lowmemjson.Encodable = ExtentCSum{}
+)
+
+func (o ExtentCSum) EncodeJSON(w io.Writer) error {
+	if _, err := fmt.Fprintf(w, `{"ChecksumSize":%d,"Sums":[`, o.ChecksumSize); err != nil {
+		return err
+	}
+	for i, sum := range o.Sums {
+		if i > 0 {
+			if _, err := w.Write([]byte(",")); err != nil {
+				return err
+			}
+		}
+		if _, err := w.Write([]byte(`"`)); err != nil {
+			return err
+		}
+		if _, err := hex.NewEncoder(w).Write(sum[:o.ChecksumSize]); err != nil {
+			return err
+		}
+		if _, err := w.Write([]byte(`"`)); err != nil {
+			return err
+		}
+	}
+	if _, err := w.Write([]byte(`]}`)); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/lib/btrfs/btrfssum/csum.go b/lib/btrfs/btrfssum/csum.go
index 8f9ac1a..c7c1f37 100644
--- a/lib/btrfs/btrfssum/csum.go
+++ b/lib/btrfs/btrfssum/csum.go
@@ -5,6 +5,7 @@
 package btrfssum
 
 import (
+	"encoding"
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
@@ -15,10 +16,29 @@ import (
 
 type CSum [0x20]byte
 
+var (
+	_ fmt.Stringer             = CSum{}
+	_ fmt.Formatter            = CSum{}
+	_ encoding.TextMarshaler   = CSum{}
+	_ encoding.TextUnmarshaler = (*CSum)(nil)
+)
+
 func (csum CSum) String() string {
 	return hex.EncodeToString(csum[:])
 }
 
+func (csum CSum) MarshalText() ([]byte, error) {
+	var ret [len(csum) * 2]byte
+	hex.Encode(ret[:], csum[:])
+	return ret[:], nil
+}
+
+func (csum *CSum) UnmarshalText(text []byte) error {
+	*csum = CSum{}
+	_, err := hex.Decode(csum[:], text)
+	return err
+}
+
 func (csum CSum) Fmt(typ CSumType) string {
 	return hex.EncodeToString(csum[:typ.Size()])
 }
diff --git a/lib/btrfsprogs/btrfsinspect/csums.go b/lib/btrfsprogs/btrfsinspect/csums.go
index 78bf915..6335cb9 100644
--- a/lib/btrfsprogs/btrfsinspect/csums.go
+++ b/lib/btrfsprogs/btrfsinspect/csums.go
@@ -6,7 +6,11 @@ package btrfsinspect
 
 import (
 	"context"
+	"fmt"
 	"io"
+	"strings"
+
+	"git.lukeshu.com/go/lowmemjson"
 
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsitem"
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsvol"
@@ -17,6 +21,82 @@ import (
 
 type ShortSum string
 
+var (
+	_ lowmemjson.Encodable = ShortSum("")
+	_ lowmemjson.Decodable = (*ShortSum)(nil)
+)
+
+func (sum ShortSum) EncodeJSON(w io.Writer) error {
+	const hextable = "0123456789abcdef"
+	var buf [2]byte
+	buf[0] = '"'
+	if _, err := w.Write(buf[:1]); err != nil {
+		return err
+	}
+	for i := 0; i < len(sum); i++ {
+		buf[0] = hextable[sum[i]>>4]
+		buf[1] = hextable[sum[i]&0x0f]
+		if _, err := w.Write(buf[:]); err != nil {
+			return err
+		}
+	}
+	buf[0] = '"'
+	if _, err := w.Write(buf[:1]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func deHex(r rune) (byte, bool) {
+	if r > 0xff {
+		return 0, false
+	}
+	c := byte(r)
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0', true
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10, true
+	case 'A' <= c && c <= 'F':
+		return c - 'A' + 10, true
+	default:
+		return 0, false
+	}
+}
+
+func (sum *ShortSum) DecodeJSON(r io.RuneScanner) error {
+	var out strings.Builder
+	if c, _, err := r.ReadRune(); err != nil {
+		return err
+	} else if c != '"' {
+		return fmt.Errorf("expected %q, got %q", '"', c)
+	}
+	for {
+		a, _, err := r.ReadRune()
+		if err != nil {
+			return err
+		}
+		if a == '"' {
+			break
+		}
+		aN, ok := deHex(a)
+		if !ok {
+			return fmt.Errorf("expected a hex digit, got %q", a)
+		}
+		b, _, err := r.ReadRune()
+		if err != nil {
+			return err
+		}
+		bN, ok := deHex(b)
+		if !ok {
+			return fmt.Errorf("expected a hex digit, got %q", b)
+		}
+		out.WriteByte(aN<<4 | bN)
+	}
+	*sum = ShortSum(out.String())
+	return nil
+}
+
 // SumRun ////////////////////////////////////////////////////////////
 
 type SumRun[Addr btrfsvol.IntAddr[Addr]] struct {
diff --git a/lib/containers/optional.go b/lib/containers/optional.go
index 3055308..c0e7b32 100644
--- a/lib/containers/optional.go
+++ b/lib/containers/optional.go
@@ -4,7 +4,33 @@
 
 package containers
 
+import (
+	"encoding/json"
+)
+
 type Optional[T any] struct {
 	OK  bool
 	Val T
 }
+
+var (
+	_ json.Marshaler   = Optional[bool]{}
+	_ json.Unmarshaler = (*Optional[bool])(nil)
+)
+
+func (o Optional[T]) MarshalJSON() ([]byte, error) {
+	if o.OK {
+		return json.Marshal(o.Val)
+	} else {
+		return []byte("null"), nil
+	}
+}
+
+func (o *Optional[T]) UnmarshalJSON(dat []byte) error {
+	if string(dat) == "null" {
+		*o = Optional[T]{}
+		return nil
+	}
+	o.OK = true
+	return json.Unmarshal(dat, &o.Val)
+}