.forgejo/workflows/test.yml

@@ -1,16 +0,0 @@
-on: [push]
-jobs:
-  build:
-    runs-on: docker
-    steps:
-      # Step 1: Check out the code
-      - uses: actions/checkout@v3
-
-      # Step 2: Set up go environment
-      - uses: actions/setup-go@v4
-        with:
-          go-version-file: '/workspace/FLUX/GoSBHPF/go.mod'
-
-      # Step 3: Set the working directory and run the project tests
-      - run: go test
-        working-directory: /workspace/FLUX/GoSBHPF/SBHPFv1

.gitignore

@@ -1,22 +0,0 @@
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# Go workspace file
-go.work
-go.work.sum
-
-# env file
-.env

.vscode/settings.json

@@ -1,10 +0,0 @@
-{
-    "cSpell.words": [
-        "SBHPF",
-        "sbhpfv",
-        "seekable",
-        "seekablebuffer",
-        "targetbytes",
-        "zervo"
-    ]
-}

README.md

@@ -1,6 +1,3 @@
 # GoSBHPF
 
-![Test status](https://git.zervo.org/FLUX/GoSBHPF/badges/workflows/test.yml/badge.svg)
+Go implementation of the SBHPF binary format.
-![Stars status](https://git.zervo.org/FLUX/GoSBHPF/badges/stars.svg)
-
-GoSBHPF is a go library implementing the SBHPF binary format.

SBHPFv1/buffered_serializer.go

@@ -1,33 +0,0 @@
-package sbhpfv1
-
-import (
-	"io"
-
-	"git.zervo.org/FLUX/GoSBHPF/pkg/seekablebuffer"
-)
-
-// SerializeNodeBuffered serializes a node object into a SBHPF node.
-// It is a wrapper around SerializeNode that temporarily stores the serialized nodes in a seekable memory buffer.
-// This provides serialization compatibility with non-seekable writers, at the cost of increased memory usage.
-func SerializeNodeBuffered(w io.Writer, node *Node) error {
-	buf := &seekablebuffer.Buffer{}
-	if err := SerializeNode(buf, node); err != nil {
-		return err
-	}
-
-	_, err := io.Copy(w, buf)
-	return err
-}
-
-// SerializeBuffered serializes a root node object into a complete SBHPF tree.
-// It is a wrapper around Serialize that temporarily stores the serialized data in a seekable memory buffer.
-// This provides serialization compatibility with non-seekable writers, at the cost of increased memory usage.
-func SerializeBuffered(w io.Writer, node *Node) error {
-	buf := &seekablebuffer.Buffer{}
-	if err := Serialize(buf, node); err != nil {
-		return err
-	}
-
-	_, err := io.Copy(w, buf)
-	return err
-}

SBHPFv1/constants.go

@@ -2,7 +2,7 @@ package sbhpfv1
 
 // Constants for file format.
 // These are statically set in version 1 of SBHPF,
-// but can be used to achieve an extended feature-set in future versions,
+// but can be used to achieve an extended featureset in future versions,
 // while maintaining backwards compatibility.
 const (
 	FormatVersion       = 0x01 // Current version

SBHPFv1/serializer.go

@@ -6,9 +6,8 @@ import (
 	"io"
 )
 
-// Serialize serializes a root node object into a complete SBHPF tree.
+// Serialize writes a full binary property file from a root node object.
 // This includes the start headers necessary for proper deserialization of raw files.
-// NOTE: Writer must support seeking. If this is not possible, use the SerializeBuffered wrapper.
 func Serialize(w io.Writer, root *Node) error {
 	// Write file header (version + feature flag).
 	if err := binary.Write(w, binary.LittleEndian, uint8(FormatVersion)); err != nil {
@@ -23,7 +22,7 @@ func Serialize(w io.Writer, root *Node) error {
 }
 
 // SerializeNode serializes a node object into a SBHPF node.
-// NOTE: Writer must support seeking. If this is not possible, use the SerializeNodeBuffered wrapper.
+// NOTE: Writer must support seeking. If this is not possible, use SerializeNodeStream.
 func SerializeNode(w io.Writer, node *Node) error {
 	// Reserve space for node size ("Node Size" node header).
 	sizePos := getWriterPosition(w)                                         // Save current position.

SBHPFv1/serializer_test.go

@@ -18,14 +18,12 @@ var (
 	}
 
 	node_ser_targetbytes = []byte{
-		// -- ROOT NODE: HEADER
+		// ROOT NODE
 		0x33, 0x00, 0x00, 0x00, // Node size = 33
 		0x02, 0x00, // Property count = 2
 		0x01, 0x00, // Child count = 1
-		0x06, // Name length = 6
+		0x06,                               // Name length = 6
-		// -- ROOT NODE: NAME
 		0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, // Node name = "player"
-		// -- ROOT NODE: PROPERTIES
 		// ROOT NODE -> PROPERTY A
 		0x06,                               // Key length = 6
 		0x0b,                               // Value type = bool
@@ -36,7 +34,6 @@ var (
 		0x03,                         // Value type = 16-bit signed int
 		0x6c, 0x65, 0x76, 0x65, 0x6c, // Key = "level"
 		0x1b, 0x00, // Value = 27
-		// -- ROOT NODE: CHILDREN
 		// ROOT NODE -> CHILD NODE
 		0x12, 0x00, 0x00, 0x00, // Node size = 12
 		0x00, 0x00, // Property count = 0
@@ -44,25 +41,6 @@ var (
 		0x09,                                                 // Name length = 9
 		0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x6f, 0x72, 0x79, // Node name = "inventory"
 	}
-
-	full_ser_targetbytes = []byte{
-		// -- FILE HEADER
-		0x01, // Version flag = 1
-		0x00, // Feature flag = 0
-		// -- ROOT NODE: HEADER
-		0x16, 0x00, 0x00, 0x00, // Node size = 16
-		0x01, 0x00, // Property count = 1
-		0x00, 0x00, // Child count = 0
-		0x04, // Name length = 4
-		// -- ROOT NODE: NAME
-		0x75, 0x73, 0x65, 0x72, // Node name = "user"
-		// -- ROOT NODE: PROPERTIES
-		// ROOT NODE -> PROPERTY
-		0x06,                               // Key length = 6
-		0x0b,                               // Value type = bool
-		0x61, 0x63, 0x74, 0x69, 0x76, 0x65, // Key = "active"
-		0x01, // Value = true
-	}
 )
 
 func TestPropertySerialization(t *testing.T) {
@@ -72,8 +50,8 @@ func TestPropertySerialization(t *testing.T) {
 		Value: "zervo",
 	}
 
-	var buf bytes.Buffer
+	buf := &bytes.Buffer{}
-	err := sbhpfv1.SerializeProperty(&buf, prop)
+	err := sbhpfv1.SerializeProperty(buf, prop)
 	if err != nil {
 		t.Fatalf("Property serialization failed: %v", err)
 	}
@@ -111,38 +89,13 @@ func TestNodeSerialization(t *testing.T) {
 		},
 	}
 
-	var buf bytes.Buffer
+	var w bytes.Buffer
-	err := sbhpfv1.SerializeNodeBuffered(&buf, &node)
+	err := sbhpfv1.SerializeNodeStream(&w, &node)
 	if err != nil {
 		t.Fatalf("Node serialization failed: %v", err)
 	}
 
-	if !slices.Equal(buf.Bytes(), node_ser_targetbytes) {
+	if !slices.Equal(w.Bytes(), node_ser_targetbytes) {
-		t.Fatalf("Node serialization generated bad data: %v", buf.Bytes())
+		t.Fatalf("Node serialization generated bad data: %v", w.Bytes())
-	}
-}
-
-func TestFullSerialization(t *testing.T) {
-	prop := sbhpfv1.Property{
-		Key:   "active",
-		Type:  sbhpfv1.TypeBool,
-		Value: true,
-	}
-
-	node := sbhpfv1.Node{
-		Name: "user",
-		Properties: []sbhpfv1.Property{
-			prop,
-		},
-	}
-
-	var buf bytes.Buffer
-	err := sbhpfv1.SerializeBuffered(&buf, &node)
-	if err != nil {
-		t.Fatalf("Full tree serialization failed: %v", err)
-	}
-
-	if !slices.Equal(buf.Bytes(), full_ser_targetbytes) {
-		t.Fatalf("Full tree serialization generated bad data: %v", buf.Bytes())
 	}
 }

SBHPFv1/streamed_serializer.go

@@ -0,0 +1,20 @@
+package sbhpfv1
+
+import (
+	"io"
+
+	"git.zervo.org/FLUX/GoSBHPF/pkg/seekablebuffer"
+)
+
+// SerializeNodeStream serializes a node object into a SBHPF node.
+// It is a wrapper around SerializeNode that temporarily stores the serialized nodes in a seekable memory buffer.
+// This is less efficient, but provides compatibility with writers that lack seeking support.
+func SerializeNodeStream(w io.Writer, node *Node) error {
+	buf := &seekablebuffer.Buffer{}
+	if err := SerializeNode(buf, node); err != nil {
+		return err
+	}
+
+	_, err := io.Copy(w, buf)
+	return err
+}

main.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	sbhpfv1 "git.zervo.org/FLUX/GoSBHPF/SBHPFv1"
+)
+
+func main() {
+	file, err := os.Create("test.bin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer file.Close()
+
+	prop_a := sbhpfv1.Property{
+		Key:   "active",
+		Type:  sbhpfv1.TypeBool,
+		Value: true,
+	}
+
+	prop_b := sbhpfv1.Property{
+		Key:   "level",
+		Type:  sbhpfv1.TypeInt16,
+		Value: int16(27),
+	}
+
+	child_node := sbhpfv1.Node{
+		Name: "inventory",
+	}
+
+	node := sbhpfv1.Node{
+		Name: "player",
+		Properties: []sbhpfv1.Property{
+			prop_a,
+			prop_b,
+		},
+		Children: []*sbhpfv1.Node{
+			&child_node,
+		},
+	}
+
+	err = sbhpfv1.SerializeNode(file, &node)
+	if err != nil {
+		log.Fatal(err)
+	}
+}