synchronous single data

Author: kuhe

packages/core/src/submodules/cbor/ByteVector.ts

@@ -1,9 +1,22 @@
-import { CborMajorType } from "./cbor";
+import { fromUtf8 } from "@smithy/util-utf8";
 
+const USE_BUFFER = typeof Buffer !== "undefined";
+const USE_TEXT_ENCODER = typeof TextEncoder !== "undefined";
+
+type BufferWithUtf8Write = Buffer & {
+  utf8Write(str: string, index: number): number;
+};
+
+/**
+ *
+ * Data container for synchronous encoding.
+ *
+ */
 export class ByteVector {
   private data: Uint8Array = new Uint8Array();
   private dataView: DataView = new DataView(this.data.buffer, 0, 0);
   private cursor: number = 0;
+  private textEncoder: TextEncoder | null = USE_TEXT_ENCODER ? new TextEncoder() : null;
 
   public constructor(private initialSize: number = 1_000_000) {
     this.resize(initialSize);
@@ -18,44 +31,70 @@ export class ByteVector {
     }
   }
 
-  public writeSeries(bytes: Uint8Array) {
+  public writeBytes(bytes: Uint8Array) {
     if (this.cursor + bytes.length >= this.data.length) {
       this.resize(this.cursor + bytes.length + this.initialSize);
     }
     this.data.set(bytes, this.cursor);
     this.cursor += bytes.byteLength;
   }
 
-  public writeUnsignedInt(major: CborMajorType, bitSize: 16 | 32 | 64, value: number | bigint) {
+  public writeUnsignedInt(major: number, bitSize: 16 | 32 | 64, value: number | bigint) {
     if (this.cursor + bitSize / 8 >= this.data.length) {
       this.resize(this.cursor + bitSize / 8 + this.initialSize);
     }
     const dv = byteVector.getDataView();
     switch (bitSize) {
       case 16:
-        this.write((major << 5) | 25);
+        this.write(major);
         dv.setUint16(byteVector.getCursor(), Number(value) as number);
         this.cursor += 2;
         break;
       case 32:
-        this.write((major << 5) | 26);
+        this.write(major);
         dv.setUint32(byteVector.getCursor(), Number(value) as number);
         this.cursor += 4;
         break;
       case 64:
-        this.write((major << 5) | 27);
+        this.write(major);
         dv.setBigUint64(byteVector.getCursor(), BigInt(value) as bigint);
         this.cursor += 8;
         break;
     }
   }
 
+  public writeFloat64(major: number, value: number) {
+    if (this.cursor + 8 >= this.data.length) {
+      this.resize(this.cursor + 8 + this.initialSize);
+    }
+    const dv = byteVector.getDataView();
+    this.write(major);
+    dv.setFloat64(this.cursor, value);
+    this.cursor += 8;
+  }
+
+  public writeString(str: string) {
+    if (this.cursor + str.length * 4 > this.data.length) {
+      this.resize(this.cursor + str.length * 4 + this.initialSize);
+    }
+    if (USE_BUFFER && (this.data as BufferWithUtf8Write).utf8Write) {
+      this.cursor += (this.data as BufferWithUtf8Write).utf8Write(str, this.cursor);
+    } else if (USE_TEXT_ENCODER && this.textEncoder?.encodeInto) {
+      this.cursor += this.textEncoder.encodeInto(str, this.data.subarray(this.cursor)).written;
+    } else {
+      const bytes = fromUtf8(str);
+      this.writeBytes(bytes);
+    }
+  }
+
   public toUint8Array(): Uint8Array {
     const out = new Uint8Array(this.cursor);
-    out.set(this.data.slice(0, this.cursor), 0);
-    this.data = new Uint8Array(this.initialSize);
+    out.set(this.data.subarray(0, this.cursor), 0);
     this.cursor = 0;
-    this.dataView = new DataView(this.data.buffer, 0, this.initialSize);
+    if (this.data.length > this.initialSize) {
+      this.data = new Uint8Array(this.initialSize);
+      this.dataView = new DataView(this.data.buffer, 0, this.initialSize);
+    }
     return out;
   }
 
@@ -70,7 +109,7 @@ export class ByteVector {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   private resize(size: number) {
     const data = this.data;
-    this.data = typeof Buffer !== "undefined" ? new Uint8Array(size) : new Uint8Array(size);
+    this.data = USE_BUFFER ? Buffer.allocUnsafeSlow(size) : new Uint8Array(size);
     if (data) {
       this.data.set(data, 0);
     }
@@ -79,17 +118,3 @@ export class ByteVector {
 }
 
 export const byteVector = new ByteVector();
-
-export function join(byteArrays: Uint8Array[]): Uint8Array {
-  let length = 0;
-  for (const arr of byteArrays) {
-    length += arr.length;
-  }
-  let offset = 0;
-  const joined = new Uint8Array(length);
-  for (const arr of byteArrays) {
-    joined.set(arr, offset);
-    offset += arr.length;
-  }
-  return joined;
-}

packages/core/src/submodules/cbor/DecodeView.ts

@@ -0,0 +1,30 @@
+import { toUtf8 } from "@smithy/util-utf8";
+
+const USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
+
+/**
+ * Data container for synchronous decoding.
+ */
+export class DecodeView {
+  public payload = new Uint8Array();
+  public dataView = new DataView(this.payload.buffer, 0, this.payload.length);
+  private textDecoder = USE_TEXT_DECODER ? new TextDecoder() : null;
+
+  public constructor(payload: Uint8Array) {
+    this.set(payload);
+  }
+
+  public set(payload: Uint8Array) {
+    this.payload = payload;
+    this.dataView = new DataView(this.payload.buffer, 0, this.payload.length);
+  }
+
+  public toUtf8(bytes: Uint8Array, at: number, to: number): string {
+    if (this.textDecoder) {
+      return this.textDecoder.decode(bytes.subarray(at, to));
+    }
+    return toUtf8(bytes.subarray(at, to));
+  }
+}
+
+export const decodeView = new DecodeView(new Uint8Array());