make Encoder/Decoder instances easily reusable

Author: gfx

benchmark/benchmark-from-msgpack-lite.ts

@@ -8,7 +8,6 @@ var msgpack_lite = try_require("msgpack-lite");
 var msgpack_js = try_require("msgpack-js");
 var msgpack_js_v5 = try_require("msgpack-js-v5");
 var msgpack5 = try_require("msgpack5");
-var msgpack_unpack = try_require("msgpack-unpack");
 var notepack = try_require("notepack");
 
 msgpack5 = msgpack5 && msgpack5();
@@ -64,6 +63,12 @@ if (msgpack_msgpack) {
   buf = bench('buf = require("@msgpack/msgpack").encode(obj);', msgpack_msgpack.encode, data);
   obj = bench('obj = require("@msgpack/msgpack").decode(buf);', msgpack_msgpack.decode, buf);
   runTest(obj);
+
+  const encoder = new msgpack_msgpack.Encoder();
+  const decoder = new msgpack_msgpack.Decoder();
+  buf = bench('buf = /* @msgpack/msgpack */ encoder.encode(obj);', (data) => encoder.encode(data), data);
+  obj = bench('obj = /* @msgpack/msgpack */ decoder.decodeSync(buf);', (buf) => decoder.decodeSync(buf), buf);
+  runTest(obj);
 }
 
 if (msgpack_js_v5) {
@@ -90,11 +95,6 @@ if (notepack) {
   runTest(obj);
 }
 
-if (msgpack_unpack) {
-  obj = bench('obj = require("msgpack-unpack").decode(buf);', msgpack_unpack, packed);
-  runTest(obj);
-}
-
 function JSON_stringify(src: any) {
   return Buffer.from(JSON.stringify(src));
 }

src/Decoder.ts

@@ -70,8 +70,8 @@ export class Decoder<ContextType> {
   readonly stack: Array<StackState> = [];
 
   constructor(
-    readonly extensionCodec: ExtensionCodecType<ContextType> = ExtensionCodec.defaultCodec as any,
     readonly context: ContextType,
+    readonly extensionCodec: ExtensionCodecType<ContextType> = ExtensionCodec.defaultCodec as any,
     readonly maxStrLength = DEFAULT_MAX_LENGTH,
     readonly maxBinLength = DEFAULT_MAX_LENGTH,
     readonly maxArrayLength = DEFAULT_MAX_LENGTH,
@@ -80,6 +80,11 @@ export class Decoder<ContextType> {
     readonly cachedKeyDecoder: CachedKeyDecoder | null = sharedCachedKeyDecoder,
   ) {}
 
+  private reinitializeState() {
+    this.totalPos = 0;
+    this.headByte = HEAD_BYTE_REQUIRED;
+  }
+
   setBuffer(buffer: ArrayLike<number> | ArrayBuffer): void {
     this.bytes = ensureUint8Array(buffer);
     this.view = createDataView(this.bytes);
@@ -106,11 +111,21 @@ export class Decoder<ContextType> {
 
   createNoExtraBytesError(posToShow: number): Error {
     const { view, pos } = this;
-    return new RangeError(`Extra ${view.byteLength - pos} byte(s) found at buffer[${posToShow}]`);
+    return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+  }
+
+  /**
+   * A synchronous interface to decode a byte buffer. It mutates the decoder instance.
+   * @param buffer A byte buffer encoded in MessagePack.
+   */
+  decodeSync(buffer: ArrayLike<number> | ArrayBuffer): unknown {
+    this.reinitializeState();
+    this.setBuffer(buffer);
+    return this.doDecodeSingleSync();
   }
 
-  decodeSingleSync(): unknown {
-    const object = this.decodeSync();
+  private doDecodeSingleSync(): unknown {
+    const object = this.doDecodeSync();
     if (this.hasRemaining()) {
       throw this.createNoExtraBytesError(this.pos);
     }
@@ -128,7 +143,7 @@ export class Decoder<ContextType> {
       this.appendBuffer(buffer);
 
       try {
-        object = this.decodeSync();
+        object = this.doDecodeSync();
         decoded = true;
       } catch (e) {
         if (!(e instanceof DataViewIndexOutOfBoundsError)) {
@@ -179,7 +194,7 @@ export class Decoder<ContextType> {
 
       try {
         while (true) {
-          yield this.decodeSync();
+          yield this.doDecodeSync();
           if (--arrayItemsLeft === 0) {
             break;
           }
@@ -194,7 +209,7 @@ export class Decoder<ContextType> {
     }
   }
 
-  decodeSync(): unknown {
+  private doDecodeSync(): unknown {
     DECODE: while (true) {
       const headByte = this.readHeadByte();
       let object: unknown;

src/Encoder.ts

@@ -13,16 +13,26 @@ export class Encoder<ContextType> {
   private bytes = new Uint8Array(this.view.buffer);
 
   constructor(
-    readonly extensionCodec: ExtensionCodecType<ContextType> = ExtensionCodec.defaultCodec as any,
     readonly context: ContextType,
+    readonly extensionCodec: ExtensionCodecType<ContextType> = ExtensionCodec.defaultCodec as any,
     readonly maxDepth = DEFAULT_MAX_DEPTH,
     readonly initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE,
     readonly sortKeys = false,
     readonly forceFloat32 = false,
     readonly ignoreUndefined = false,
   ) {}
 
-  encode(object: unknown, depth: number): void {
+  private reinitializeState() {
+    this.pos = 0;
+  }
+
+  encode(object: unknown): Uint8Array {
+    this.reinitializeState();
+    this.doEncode(object, 1);
+    return this.getUint8Array();
+  }
+
+  doEncode(object: unknown, depth: number): void {
     if (depth > this.maxDepth) {
       throw new Error(`Too deep objects in depth ${depth}`);
     }
@@ -228,7 +238,7 @@ export class Encoder<ContextType> {
       throw new Error(`Too large array: ${size}`);
     }
     for (const item of object) {
-      this.encode(item, depth + 1);
+      this.doEncode(item, depth + 1);
     }
   }
 
@@ -272,7 +282,7 @@ export class Encoder<ContextType> {
 
       if (!(this.ignoreUndefined && value === undefined)) {
         this.encodeString(key);
-        this.encode(value, depth + 1);
+        this.doEncode(value, depth + 1);
       }
     }
   }

src/decode.ts

@@ -47,14 +47,13 @@ export function decode<ContextType>(
   options: DecodeOptions<SplitUndefined<ContextType>> = defaultDecodeOptions as any,
 ): unknown {
   const decoder = new Decoder<ContextType>(
-    options.extensionCodec,
     (options as typeof options & { context: any }).context,
+    options.extensionCodec,
     options.maxStrLength,
     options.maxBinLength,
     options.maxArrayLength,
     options.maxMapLength,
     options.maxExtLength,
   );
-  decoder.setBuffer(buffer); // decodeSync() requires only one buffer
-  return decoder.decodeSingleSync();
+  return decoder.decodeSync(buffer);
 }

src/decodeAsync.ts

@@ -10,8 +10,8 @@ export async function decodeAsync<ContextType>(
   const stream = ensureAsyncIterabe(streamLike);
 
   const decoder = new Decoder<ContextType>(
-    options.extensionCodec,
     (options as typeof options & { context: any }).context,
+    options.extensionCodec,
     options.maxStrLength,
     options.maxBinLength,
     options.maxArrayLength,
@@ -28,8 +28,8 @@ export function decodeArrayStream<ContextType>(
   const stream = ensureAsyncIterabe(streamLike);
 
   const decoder = new Decoder<ContextType>(
-    options.extensionCodec,
     (options as typeof options & { context: any }).context,
+    options.extensionCodec,
     options.maxStrLength,
     options.maxBinLength,
     options.maxArrayLength,
@@ -47,8 +47,8 @@ export function decodeStream<ContextType>(
   const stream = ensureAsyncIterabe(streamLike);
 
   const decoder = new Decoder<ContextType>(
-    options.extensionCodec,
     (options as typeof options & { context: any }).context,
+    options.extensionCodec,
     options.maxStrLength,
     options.maxBinLength,
     options.maxArrayLength,

src/encode.ts

@@ -40,14 +40,13 @@ export function encode<ContextType>(
   options: EncodeOptions<SplitUndefined<ContextType>> = defaultEncodeOptions as any,
 ): Uint8Array {
   const encoder = new Encoder<ContextType>(
-    options.extensionCodec,
     (options as typeof options & { context: any }).context,
+    options.extensionCodec,
     options.maxDepth,
     options.initialBufferSize,
     options.sortKeys,
     options.forceFloat32,
     options.ignoreUndefined,
   );
-  encoder.encode(value, 1);
-  return encoder.getUint8Array();
+  return encoder.encode(value);
 }

test/reuse-instances.test.ts

@@ -0,0 +1,41 @@
+import { deepStrictEqual } from "assert";
+import { Encoder, Decoder } from "@msgpack/msgpack";
+
+describe("shared instances", () => {
+  context("Encoder and Decoder", () => {
+    const encoder = new Encoder(undefined);
+    const decoder = new Decoder(undefined);
+
+    it("runs #1", () => {
+      const object = {
+        nil: null,
+        integer: 1,
+        float: Math.PI,
+        string: "Hello, world!",
+        binary: Uint8Array.from([1, 2, 3]),
+        array: [10, 20, 30],
+        map: { foo: "bar" },
+        timestampExt: new Date(),
+      };
+
+      const encoded: Uint8Array = encoder.encode(object);
+      deepStrictEqual(decoder.decodeSync(encoded), object);
+    });
+
+    it("runs #2", () => {
+      const object = {
+        nil: null,
+        integer: 1,
+        float: Math.PI,
+        string: "Hello, world!",
+        binary: Uint8Array.from([1, 2, 3]),
+        array: [10, 20, 30],
+        map: { foo: "bar" },
+        timestampExt: new Date(),
+      };
+
+      const encoded: Uint8Array = encoder.encode(object);
+      deepStrictEqual(decoder.decodeSync(encoded), object);
+    });
+  });
+});