Added FlexIntType

Author: calebsander

README.md

@@ -20,6 +20,7 @@ A lot of data, especially data designed to be used in many different languages,
 - Use when there is a lot of repetition in the data. If you don't have any arrays, sets, or maps, you can't really benefit from the cutdown on redundancy.
 
 ## Differences from Protocol Buffers
+- Types have binary serializations, not just values. (Protocol Buffers requires both the sender and receiver to have `.proto` definition files, which are not designed to be transmitted like values.) This makes storage of complex types much more compact and allows for sending values of types the receiver has not yet seen.
 - Types are generated programmatically rather than by reading `.proto` files. This allows for functionality like a function which turns a type into another type that either contains an error message or an instance of the original type.
 - This project is designed with downloading data of known types from servers over HTTP in mind. If the client has already received data of the same type, the server only sends the value and the client reads it using its cached type. If the client doesn't know what the type looks like, the server sends it in byte form along with the value and the client caches the type. This way, the type does not need to be specified in the client-side JavaScript and repeated requests are very efficient.
 - `structure-bytes` provides a larger set of primitive and recursive types.
@@ -31,12 +32,13 @@ A lot of data, especially data designed to be used in many different languages,
 	- `Int` (4-byte signed integer)
 	- `Long` (8-byte signed integer)
 	- `BigInt` (a signed integer with arbitrary precision)
+	- `FlexInt` (a signed integer from `-(2 ** 52)` to `2 ** 52` with a variable-length representation)
 	- `UnsignedByte` (1-byte unsigned integer)
 	- `UnsignedShort` (2-byte unsigned integer)
 	- `UnsignedInt` (4-byte unsigned integer)
 	- `UnsignedLong` (8-byte unsigned integer)
 	- `BigUnsignedInt` (an unsigned integer with arbitrary precision)
-	- `FlexUnsignedInt` (an unsigned integer below `2^53` with a variable-length representation)
+	- `FlexUnsignedInt` (an unsigned integer below `2 ** 53` with a variable-length representation)
 	- `Date` (8-byte unsigned integer representing number of milliseconds since Jan 1, 1970)
 	- `Day` (3-byte unsigned integer representing a specific day in history)
 	- `Time` (4-byte unsigned integer representing a specific time of day)
@@ -474,6 +476,7 @@ In the following definitions, `type` means the binary type format.
 - `IntType`: identifier `0x03`
 - `LongType`: identifier `0x04`
 - `BigIntType`: identifier `0x05`
+- `FlexIntType`: identifier `0x07`
 - `UnsignedByteType`: identifier `0x11`
 - `UnsignedShortType`: identifier `0x12`
 - `UnsignedIntType`: identifier `0x13`
@@ -541,6 +544,7 @@ In the following definitions, `type` means the binary type format.
 - `BigIntType`:
 	- `byteCount` - `flexInt`
 	- `number` - `byteCount`-byte integer
+- `FlexIntType`: `flexInt` of `value * 2` if `value` is non-negative, `-2 * value - 1` if `value` is negative
 - `UnsignedByteType`: 1-byte unsigned integer
 - `UnsignedShortType`: 2-byte unsigned integer
 - `UnsignedIntType`: 4-byte unsigned integer

compiled/download.js

@@ -24,6 +24,7 @@
  *     - [[IntType]]
  *     - [[LongType]]
  *     - [[BigIntType]]
+ *     - [[FlexIntType]]
  *   - Unsigned integer types
  *     - [[UnsignedByteType]]
  *     - [[UnsignedShortType]]

compiled/upload-download.js

@@ -25,6 +25,7 @@
  *     - [[IntType]]
  *     - [[LongType]]
  *     - [[BigIntType]]
+ *     - [[FlexIntType]]
  *   - Unsigned integer types
  *     - [[UnsignedByteType]]
  *     - [[UnsignedShortType]]

compiled/upload.js

@@ -50,7 +50,7 @@ function integer(instance) {
  */
 function between(lower, value, upper, message) {
     if (value < lower || value >= upper) {
-        const outOfBoundsMessage = util_inspect_1.inspect(value) +
+        const outOfBoundsMessage = String(value) +
             ' is not in [' +
             String(lower) +
             ',' +

dist/index.d.ts

@@ -13,11 +13,9 @@ const UPPER_BOUNDS = new Map(); //mapping of numbers of bytes to the exclusive u
 {
     let cumulativeValues = 0;
     let bytes = 1;
-    while (true) {
+    while (cumulativeValues <= Number.MAX_SAFE_INTEGER) {
         cumulativeValues += possibleValueCount(bytes);
         UPPER_BOUNDS.set(bytes, cumulativeValues);
-        if (cumulativeValues > Number.MAX_SAFE_INTEGER)
-            break;
         bytes++;
     }
 }
@@ -51,19 +49,18 @@ function makeValueBuffer(value) {
         throw new Error('Cannot represent ' + String(value)); //should never occur
     })();
     const writeValue = value - (UPPER_BOUNDS.get(bytes - 1) || 0);
-    const buffer = new ArrayBuffer(bytes);
-    const castBuffer = new Uint8Array(buffer);
+    const buffer = new Uint8Array(bytes);
     {
         let shiftedValue = writeValue;
         for (let writeByte = bytes - 1; writeByte >= 0; writeByte--) {
-            castBuffer[writeByte] = shiftedValue & 0xFF; //write least significant byte
+            buffer[writeByte] = shiftedValue & 0xFF; //write least significant byte
             //Move next least significant byte to least significant byte
             //Can't use bitwise math here because number may not fit in 32 bits
             shiftedValue = Math.floor(shiftedValue / 0x100);
         }
     }
-    castBuffer[0] |= BYTE_MASKS.get(bytes);
-    return buffer;
+    buffer[0] |= BYTE_MASKS.get(bytes);
+    return buffer.buffer;
 }
 exports.makeValueBuffer = makeValueBuffer;
 /**

dist/index.js

@@ -13,6 +13,7 @@ const util_inspect_1 = require("./lib/util-inspect");
 const recursiveRegistry = require("./recursive-registry");
 const t = require("./types");
 const abstract_1 = require("./types/abstract");
+const flex_int_1 = require("./types/flex-int");
 const NOT_LONG_ENOUGH = 'Buffer is not long enough';
 function readFlexInt(buffer, offset) {
     assert_1.default(buffer.byteLength > offset, NOT_LONG_ENOUGH);
@@ -24,29 +25,17 @@ function readFlexInt(buffer, offset) {
     };
 }
 //Types whose type bytes are only 1 byte long (the type byte)
-const SINGLE_BYTE_TYPES = new Set([
-    t.ByteType,
-    t.ShortType,
-    t.IntType,
-    t.LongType,
-    t.BigIntType,
-    t.UnsignedByteType,
-    t.UnsignedShortType,
-    t.UnsignedIntType,
-    t.UnsignedLongType,
-    t.BigUnsignedIntType,
-    t.FlexUnsignedIntType,
-    t.DateType,
-    t.DayType,
-    t.TimeType,
-    t.FloatType,
-    t.DoubleType,
-    t.BooleanType,
-    t.BooleanArrayType,
-    t.CharType,
-    t.StringType,
-    t.OctetsType
-]);
+const SINGLE_BYTE_TYPES = new Set();
+{
+    const defaultAddToBuffer = abstract_1.default.prototype.addToBuffer;
+    const tTypes = t;
+    //tslint:disable-next-line:forin
+    for (const typeName in tTypes) {
+        const testType = tTypes[typeName];
+        if (testType.prototype.addToBuffer === defaultAddToBuffer)
+            SINGLE_BYTE_TYPES.add(testType);
+    }
+}
 //Mapping of type bytes to the corresponding types
 const SINGLE_BYTE_TYPE_BYTES = new Map();
 for (const singleByteType of SINGLE_BYTE_TYPES) {
@@ -180,6 +169,11 @@ function consumeValue({ buffer, offset, type: readType, baseValue }) {
             length += bytes;
             break;
         }
+        case t.FlexIntType: {
+            ({ value: readValue, length } = readFlexInt(buffer, offset));
+            readValue = flex_int_1.fromUnsigned(readValue);
+            break;
+        }
         case t.UnsignedByteType: {
             length = 1;
             assert_1.default(buffer.byteLength > offset, NOT_LONG_ENOUGH);

dist/lib/assert.js

@@ -1,55 +1,36 @@
 import AppendableBuffer from '../lib/appendable';
-import UnsignedType from './unsigned';
+import IntegerType from './integer';
 /**
- * A type storing any unsigned integer
- * that can be represented precisely in a double
- * (from `0` to `9007199254740991` (`2 ** 53 - 1`)).
- * Rather than having a fixed-length value representation,
- * more bytes are needed to represent larger values.
- * This is inspired by the UTF-8 format:
- * large values can be stored, but since most values
- * are small, fewer bytes are used in the typical case.
- * If values are uniformly distributed rather than
- * concentrated among smaller values, you will likely get
- * more efficient serializations from a fixed-width integer.
- * For example, when writing outputs of a 32-bit hash function,
- * you should use [[UnsignedIntType]] instead.
- *
- * The number of bytes required for numbers are as follows:
- * <table>
- *   <thead>
- *     <tr>
- *       <th>Min</th>
- *       <th>Max</th>
- *       <th>Bytes</th>
- *     </tr>
- *   </thead>
- *   <tbody>
- *     <tr><td>0</td><td>127</td><td>1</td></tr>
- *     <tr><td>128</td><td>16511</td><td>2</td></tr>
- *     <tr><td>16512</td><td>2113663</td><td>3</td></tr>
- *     <tr><td>2113664</td><td>270549119</td><td>4</td></tr>
- *     <tr><td>270549120</td><td>34630287487</td><td>5</td></tr>
- *     <tr><td>34630287488</td><td>4432676798591</td><td>6</td></tr>
- *     <tr><td>4432676798592</td><td>567382630219903</td><td>7</td></tr>
- *     <tr><td>567382630219904</td><td>9007199254740991</td><td>8</td></tr>
- *   </tbody>
- * </table>
+ * Converts an unsigned integer value
+ * to a unique signed integer value.
+ * The inverse of [[toUnsigned]].
+ * @param signed The unsigned integer value
+ */
+export declare function fromUnsigned(unsigned: number): number;
+/**
+ * Works like [[FlexUnsignedIntType]],
+ * but allows for negative values as well.
+ * Less efficient for storing positive values
+ * than [[FlexUnsignedIntType]], so use that
+ * instead if not storing negative values.
+ * Also limited to values between
+ * `-(2 ** 52)` and `2 ** 52 - 1`.
+ * (Encodes `value` as approximately `2 * abs(value)`.)
  *
  * Example:
  * ````javascript
- * let type = new sb.FlexUnsignedIntType
+ * let type = new sb.FlexIntType
  * ````
  */
-export default class FlexUnsignedIntType extends UnsignedType<number | string> {
+export default class FlexIntType extends IntegerType<number | string> {
     static readonly _value: number;
     /**
      * Appends value bytes to an [[AppendableBuffer]] according to the type
      *
      * Example:
      * ````javascript
      * //Takes 4 bytes
-     * type.writeValue(buffer, 2113664) //or '2113664'
+     * type.writeValue(buffer, -2113664) //or '-2113664'
      * ````
      * @param buffer The buffer to which to append
      * @param value The value to write