refactor CachedKeyDecoder

Author: gfx

src/CachedKeyDecoder.ts

@@ -1,25 +1,25 @@
 import { utf8DecodeJs } from "./utils/utf8";
 
-interface KeyCacheRecord {
-  readonly bytes: Uint8Array;
-  readonly value: string;
-}
-
 const DEFAULT_MAX_KEY_LENGTH = 16;
 const DEFAULT_MAX_LENGTH_PER_KEY = 16;
 
 export interface KeyDecoder {
   canBeCached(byteLength: number): boolean;
   decode(bytes: Uint8Array, inputOffset: number, byteLength: number): string;
 }
+interface KeyCacheRecord {
+  readonly bytes: Uint8Array;
+  readonly str: string;
+}
 
 export class CachedKeyDecoder implements KeyDecoder {
   hit = 0;
   miss = 0;
   private readonly caches: Array<Array<KeyCacheRecord>>;
 
   constructor(readonly maxKeyLength = DEFAULT_MAX_KEY_LENGTH, readonly maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
-    // avoid `new Array(N)` to create a non-sparse array for performance.
+    // avoid `new Array(N)`, which makes a sparse array,
+    // because a sparse array is typically slower than a non-sparse array.
     this.caches = [];
     for (let i = 0; i < this.maxKeyLength; i++) {
       this.caches.push([]);
@@ -30,7 +30,7 @@ export class CachedKeyDecoder implements KeyDecoder {
     return byteLength > 0 && byteLength <= this.maxKeyLength;
   }
 
-  private get(bytes: Uint8Array, inputOffset: number, byteLength: number): string | null {
+  private find(bytes: Uint8Array, inputOffset: number, byteLength: number): string | null {
     const records = this.caches[byteLength - 1]!;
 
     FIND_CHUNK: for (const record of records) {
@@ -41,36 +41,36 @@ export class CachedKeyDecoder implements KeyDecoder {
           continue FIND_CHUNK;
         }
       }
-      return record.value;
+      return record.str;
     }
     return null;
   }
 
   private store(bytes: Uint8Array, value: string) {
     const records = this.caches[bytes.length - 1]!;
-    const record: KeyCacheRecord = { bytes, value };
+    const record: KeyCacheRecord = { bytes, str: value };
 
     if (records.length >= this.maxLengthPerKey) {
       // `records` are full!
-      // Set `record` to a randomized position.
+      // Set `record` to an arbitrary position.
       records[(Math.random() * records.length) | 0] = record;
     } else {
       records.push(record);
     }
   }
 
   public decode(bytes: Uint8Array, inputOffset: number, byteLength: number): string {
-    const cachedValue = this.get(bytes, inputOffset, byteLength);
+    const cachedValue = this.find(bytes, inputOffset, byteLength);
     if (cachedValue != null) {
       this.hit++;
       return cachedValue;
     }
     this.miss++;
 
-    const value = utf8DecodeJs(bytes, inputOffset, byteLength);
+    const str = utf8DecodeJs(bytes, inputOffset, byteLength);
     // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
     const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
-    this.store(slicedCopyOfBytes, value);
-    return value;
+    this.store(slicedCopyOfBytes, str);
+    return str;
   }
 }

test/CachedKeyDecoder.test.ts

@@ -1,15 +1,15 @@
 import assert from "assert";
-import { CachedKeyDecoder } from "../src/CachedKeyDecoder";
+import { CachedKeyDecoder, KeyDecoder } from "../src/CachedKeyDecoder";
 import { utf8EncodeJs, utf8Count } from "../src/utils/utf8";
 
-function tryDecode(decoder: CachedKeyDecoder, str: string): string {
+function tryDecode(keyDecoder: KeyDecoder, str: string): string {
   const byteLength = utf8Count(str);
   const bytes = new Uint8Array(byteLength);
   utf8EncodeJs(str, bytes, 0);
-  if (!decoder.canBeCached(byteLength)) {
+  if (!keyDecoder.canBeCached(byteLength)) {
     throw new Error("Unexpected precondition");
   }
-  return decoder.decode(bytes, 0, byteLength);
+  return keyDecoder.decode(bytes, 0, byteLength);
 }
 
 describe("CachedKeyDecoder", () => {