refactor: major refactor of byte_type

benchmarks/popular_encodings.ts

@@ -0,0 +1,115 @@
+import { cstring, InnerType, Struct, u32, u8 } from "../mod.ts";
+import {
+  decode as msgpackRead,
+  encode as msgpackWrite,
+} from "std/msgpack/mod.ts";
+
+const descriptor = {
+  handIndex: u8,
+  fieldIndex: u8,
+  card: new Struct({
+    name: cstring,
+    hp: u8,
+    damage: u8,
+    shield: u32,
+  }),
+};
+
+const codec = new Struct(descriptor);
+
+const data: InnerType<typeof codec> = {
+  handIndex: 255,
+  fieldIndex: 255,
+  card: {
+    name: "InvalidCard",
+    hp: 255,
+    damage: 255,
+    shield: 255,
+  },
+};
+
+const jsonString = JSON.stringify(data);
+const msgPackBuff = msgpackWrite(data);
+
+const ARRAY_BUFFER = new ArrayBuffer(codec.byteLength);
+const DATA_VIEW = new DataView(ARRAY_BUFFER);
+
+Deno.bench("nop", () => {});
+
+Deno.bench({
+  name: "JSON (Write)",
+  group: "write",
+  baseline: true,
+  fn: () => {
+    JSON.stringify(data);
+  },
+});
+
+Deno.bench({
+  name: "JSON (Read)",
+  group: "read",
+  baseline: true,
+  fn: () => {
+    JSON.parse(jsonString);
+  },
+});
+
+Deno.bench({
+  name: "JSON (Roundtrip)",
+  group: "roundtrip",
+  baseline: true,
+  fn: () => {
+    JSON.stringify(data);
+    JSON.parse(jsonString);
+  },
+});
+
+Deno.bench({
+  name: "Struct (Write)",
+  group: "write",
+  fn: () => {
+    codec.writeUnaligned(data, DATA_VIEW);
+  },
+});
+
+Deno.bench({
+  name: "Struct (Read)",
+  group: "read",
+  fn: () => {
+    codec.readUnaligned(DATA_VIEW);
+  },
+});
+
+Deno.bench({
+  name: "Struct (Roundtrip)",
+  group: "roundtrip",
+  fn: () => {
+    codec.writeUnaligned(data, DATA_VIEW);
+    codec.readUnaligned(DATA_VIEW);
+  },
+});
+
+Deno.bench({
+  name: "MsgPack (Write)",
+  group: "write",
+  fn: () => {
+    msgpackWrite(data);
+  },
+});
+
+Deno.bench({
+  name: "MsgPack (Read)",
+  group: "read",
+  fn: () => {
+    msgpackRead(msgPackBuff);
+  },
+});
+
+Deno.bench({
+  name: "MsgPack (Roundtrip)",
+  group: "roundtrip",
+  fn: () => {
+    msgpackWrite(data);
+    msgpackRead(msgPackBuff);
+  },
+});

benchmarks/string.ts

@@ -1,6 +1,6 @@
-import { FixedLengthString } from "../mod.ts";
+import { Strings } from "../mod.ts";
 
-const stringThing = new FixedLengthString(12);
+const stringThing = new Strings.FixedLength(12);
 
 const ab = new TextEncoder().encode("Hello World!").buffer;
 const dt = new DataView(ab);

benchmarks/struct.ts

@@ -1,13 +1,12 @@
-import { AlignedStruct, u32 } from "../mod.ts";
+import { Struct, u32 } from "../mod.ts";
 
 const data = new DataView(new ArrayBuffer(8));
 
 const object = { a: 123, b: 456 };
-const struct = new AlignedStruct({
+const struct = new Struct({
   a: u32,
   b: u32,
 });
-const view = struct.view(data);
 
 Deno.bench("no-op", () => {});
 
@@ -29,15 +28,6 @@ Deno.bench({
   },
 });
 
-Deno.bench({
-  name: "view",
-  group: "read",
-  fn: () => {
-    view.a;
-    view.b;
-  },
-});
-
 Deno.bench({
   name: "DataView",
   group: "read",
@@ -68,15 +58,6 @@ Deno.bench({
   },
 });
 
-Deno.bench({
-  name: "view",
-  group: "write",
-  fn: () => {
-    view.a = 0xffff;
-    view.b = 0xffff;
-  },
-});
-
 Deno.bench({
   name: "DataView",
   group: "write",

examples/basic.ts

@@ -1,8 +1,9 @@
-import { PackedStruct, u32, u8 } from "../types/mod.ts";
+import { Struct, u32, u8 } from "../src/mod.ts";
 
-const o = new PackedStruct({ "b": u8, "a": u32 }).view(
-  new DataView(new ArrayBuffer(5)),
-  0,
-);
+const buffer = new ArrayBuffer(8);
+const dt = new DataView(buffer);
 
-console.log(o.valueOf());
+const o = new Struct({ "b": u8, "a": u32 });
+
+o.write({ b: 8, a: 32 }, dt);
+console.log(o.read(dt));

mod.ts

@@ -1,2 +1 @@
-export * from "./types/mod.ts";
-export * from "./utils.ts";
+export * from "./src/mod.ts";

src/array/array.ts

@@ -0,0 +1,69 @@
+import { AlignedType, type Options, type Packed } from "../types/mod.ts";
+
+export class ArrayType<T> extends AlignedType<T[]> implements Packed<T[]> {
+  constructor(readonly type: AlignedType<T>, readonly length: number) {
+    super(type.byteAlignment);
+  }
+
+  readUnaligned(dt: DataView, options: Options = { byteOffset: 0 }): T[] {
+    if (this.length === 0) return [];
+
+    const result = [];
+    result.length = this.length;
+    result[0] = this.type.readUnaligned(dt, options);
+
+    for (let i = 1; i < this.length; i++) {
+      result[i] = this.type.read(dt, options);
+      // No need for the increment offset. This is handled by the `type.read` function
+    }
+
+    return result;
+  }
+
+  readPacked(dt: DataView, options?: Options | undefined): T[] {
+    if (this.length === 0) return [];
+    const result = [];
+    result.length = this.length;
+
+    for (let i = 0; i < this.length; i++) {
+      result[i] = this.type.readUnaligned(dt, options);
+      // No need for the increment offset. This is handled by the `type.readUnaligned` function
+    }
+
+    return result;
+  }
+
+  writeUnaligned(
+    value: T[],
+    dt: DataView,
+    options: Options = { byteOffset: 0 },
+  ): void {
+    if (value.length !== this.length) {
+      throw new TypeError("T[].length !== ArrayType<T>.length");
+    }
+    if (value.length === 0) return;
+
+    this.type.writeUnaligned(value[0], dt, options);
+
+    for (let i = 1; i < this.length; i++) {
+      this.type.write(value[i], dt, options);
+      // No need for the increment offset. This is handled by the `type.write` function
+    }
+  }
+
+  writePacked(
+    value: T[],
+    dt: DataView,
+    options: Options = { byteOffset: 0 },
+  ): void {
+    if (value.length !== this.length) {
+      throw new TypeError("T[].length !== ArrayType<T>.length");
+    }
+    if (value.length === 0) return;
+
+    for (let i = 0; i < this.length; i++) {
+      this.type.writeUnaligned(value[i], dt, options);
+      // No need for the increment offset. This is handled by the `type.writeUnaligned` function
+    }
+  }
+}

src/array/array_buffer.ts

@@ -0,0 +1,47 @@
+import { type Options, SizedType } from "../types/mod.ts";
+
+export class ArrayBufferType extends SizedType<ArrayBuffer> {
+  constructor(byteSize: number, byteAlignment = 1) {
+    super(byteSize, byteAlignment);
+  }
+
+  readUnaligned(
+    dt: DataView,
+    options: Options = { byteOffset: 0 },
+  ): ArrayBuffer {
+    super.rangeCheck(dt.byteLength, options.byteOffset);
+
+    const resultAB = new ArrayBuffer(this.byteSize);
+    const resultView = new Uint8Array(resultAB);
+
+    resultView.set(
+      new Uint8Array(
+        dt.buffer,
+        dt.byteOffset + options.byteOffset,
+        this.byteSize,
+      ),
+    );
+
+    super.incrementOffset(options);
+
+    return resultAB;
+  }
+
+  writeUnaligned(
+    value: ArrayBuffer,
+    dt: DataView,
+    options: Options = { byteOffset: 0 },
+  ): void {
+    super.rangeCheck(dt.byteLength, options.byteOffset);
+
+    const view = new Uint8Array(
+      dt.buffer,
+      dt.byteOffset + options.byteOffset,
+      this.byteSize,
+    );
+
+    view.set(new Uint8Array(value));
+
+    super.incrementOffset(options);
+  }
+}