Add UTF-8

Author: schmidt-sebastian

packages/firestore/src/index/ordered_code_writer.ts

@@ -15,6 +15,20 @@
  * limitations under the License.
  */
 
+import { ByteString } from '../util/byte_string';
+
+/** These constants are taken from the backend. */
+const MIN_SURROGATE = '\uD800';
+const MAX_SURROGATE = '\uDBFF';
+
+const ESCAPE1 = 0x00;
+const NULL_BYTE = 0xff; // Combined with ESCAPE1
+const SEPARATOR = 0x01; // Combined with ESCAPE1
+
+const ESCAPE2 = 0xff;
+const INFINITY = 0xff; // Combined with ESCAPE2
+const FF_BYTE = 0x00; // Combined with ESCAPE2
+
 const LONG_SIZE = 64;
 const BYTE_SIZE = 8;
 
@@ -96,6 +110,70 @@ export class OrderedCodeWriter {
   buffer = new Uint8Array(DEFAULT_BUFFER_SIZE);
   position = 0;
 
+  /**
+   * Writes utf8 bytes into this byte sequence, ascending.
+   *
+   * This is a more efficent version of writeBytesAscending(str.getBytes(UTF_8));
+   */
+  writeUtf8Ascending(sequence: string): void {
+    const utf16Length = sequence.length;
+    let i = 0;
+    while (i < utf16Length) {
+      const char = sequence[i];
+      const charCode = sequence.charCodeAt(i);
+      if (charCode < 0x80) {
+        this.writeByteAscending(charCode);
+      } else if (charCode < 0x800) {
+        this.writeByteAscending((0xf >> 6) | (charCode >>> 6));
+        this.writeByteAscending(0x80 | (0x3f & charCode));
+      } else if (char < MIN_SURROGATE || MAX_SURROGATE < char) {
+        this.writeByteAscending((0xf >> 5) | (charCode >>> 12));
+        this.writeByteAscending(0x80 | (0x3f & (charCode >>> 6)));
+        this.writeByteAscending(0x80 | (0x3f & charCode));
+      } else {
+        ++i; // Skip the low surrogate.
+        this.writeByteAscending((0xf >> 4) | (charCode >>> 18));
+        this.writeByteAscending(0x80 | (0x3f & (charCode >>> 12)));
+        this.writeByteAscending(0x80 | (0x3f & (charCode >>> 6)));
+        this.writeByteAscending(0x80 | (0x3f & charCode));
+      }
+      ++i;
+    }
+    this.writeSeparatorAscending();
+  }
+
+  /**
+   * Writes utf8 bytes into this byte sequence, descending.
+   *
+   * This is a more efficent version of writeBytesDescending(str.getBytes(UTF_8));
+   */
+  writeUtf8Descending(sequence: string): void {
+    const utf16Length = sequence.length;
+    let i = 0;
+    while (i < utf16Length) {
+      const char = sequence[i];
+      const charCode = sequence.charCodeAt(i);
+      if (charCode < 0x80) {
+        this.writeByteDescending(charCode);
+      } else if (charCode < 0x800) {
+        this.writeByteDescending((0xf >> 6) | (charCode >>> 6));
+        this.writeByteDescending(0x80 | (0x3f & charCode));
+      } else if (char < MIN_SURROGATE || MAX_SURROGATE < char) {
+        this.writeByteDescending((0xf >> 5) | (charCode >>> 12));
+        this.writeByteDescending(0x80 | (0x3f & (charCode >>> 6)));
+        this.writeByteDescending(0x80 | (0x3f & charCode));
+      } else {
+        ++i; // Skip the low surrogate.
+        this.writeByteDescending((0xf >> 4) | (charCode >>> 18));
+        this.writeByteDescending(0x80 | (0x3f & (charCode >>> 12)));
+        this.writeByteDescending(0x80 | (0x3f & (charCode >>> 6)));
+        this.writeByteDescending(0x80 | (0x3f & charCode));
+      }
+      ++i;
+    }
+    this.writeSeparatorDescending();
+  }
+
   writeNumberAscending(val: number): void {
     const value = this.toOrderedBits(val);
     const len = unsignedNumLength(value);
@@ -143,6 +221,56 @@ export class OrderedCodeWriter {
     return this.buffer.slice(0, this.position);
   }
 
+  /**
+   * Writes a single byte ascending to the buffer, doing proper escaping as described in [ ].
+   */
+  private writeByteAscending(b: number): void {
+    if (b === ESCAPE1) {
+      this.writeEscapedByteAscending(ESCAPE1);
+      this.writeEscapedByteAscending(NULL_BYTE);
+    } else if (b === ESCAPE2) {
+      this.writeEscapedByteAscending(ESCAPE2);
+      this.writeEscapedByteAscending(FF_BYTE);
+    } else {
+      this.writeEscapedByteAscending(b);
+    }
+  }
+
+  /**
+   * Writes a single byte descending to the buffer, doing proper escaping as described in [ ].
+   */
+  private writeByteDescending(b: number): void {
+    if (b === ESCAPE1) {
+      this.writeEscapedByteDescending(ESCAPE1);
+      this.writeEscapedByteDescending(NULL_BYTE);
+    } else if (b === ESCAPE2) {
+      this.writeEscapedByteDescending(ESCAPE2);
+      this.writeEscapedByteDescending(FF_BYTE);
+    } else {
+      this.writeEscapedByteDescending(b);
+    }
+  }
+
+  private writeSeparatorAscending(): void {
+    this.writeEscapedByteAscending(ESCAPE1);
+    this.writeEscapedByteAscending(SEPARATOR);
+  }
+
+  private writeSeparatorDescending(): void {
+    this.writeEscapedByteDescending(ESCAPE1);
+    this.writeEscapedByteDescending(SEPARATOR);
+  }
+
+  private writeEscapedByteAscending(b: number): void {
+    this.ensureAvailable(1);
+    this.buffer[this.position++] = b;
+  }
+
+  private writeEscapedByteDescending(b: number): void {
+    this.ensureAvailable(1);
+    this.buffer[this.position++] = ~b;
+  }
+
   private ensureAvailable(bytes: number): void {
     const minCapacity = bytes + this.position;
     if (minCapacity <= this.buffer.length) {