Added flex int type

Author: calebsander

lib/assert.js

@@ -16,7 +16,15 @@ module.exports = class assert {
 				break
 			}
 		}
-		if (!constructorMatched) throw new TypeError(util.inspect(instance) + ' is not an instance of ' + constructors.map(constructor => constructor.name).join(' or '))
+		if (!constructorMatched) {
+			throw new TypeError(
+				util.inspect(instance) +
+				' is not an instance of ' +
+				constructors
+					.map(constructor => constructor.name)
+						.join(' or ')
+			)
+		}
 	}
 	//Assert that a number is an integer (within the +/-2^53 that can be represented precisely in a double)
 	static integer(instance) {

lib/flex-int.js

@@ -0,0 +1,84 @@
+const assert = require(__dirname + '/assert.js')
+
+const possibleValueCount = bytes => {
+	const usableBits = 7 * bytes
+	return Math.pow(2, usableBits)
+}
+const UPPER_BOUNDS = new Map //mapping of numbers of bytes to the exclusive upper bound on numbers in the range
+{
+	let cumulativeValues = 0
+	let bytes = 0
+	while (cumulativeValues <= Number.MAX_SAFE_INTEGER) {
+		UPPER_BOUNDS.set(bytes, cumulativeValues)
+		bytes++
+		cumulativeValues += possibleValueCount(bytes)
+	}
+}
+//Mapping of the number of leading ones in the first byte's mask to the number of bytes
+const NUMBER_OF_BYTES = new Map
+//Mapping of numbers of bytes to the mask for the first byte
+//Goes 0b00000000, 0b10000000, 0b11000000, etc.
+const BYTE_MASKS = new Map
+{
+	let mask = 0
+	let bitToMaskNext = 7 //0 is least significant bit, 7 is most significant bit
+	for (const [bytes, _] of UPPER_BOUNDS) {
+		if (!bytes) continue //should never be writing with 0 bytes
+
+		BYTE_MASKS.set(bytes, mask)
+		NUMBER_OF_BYTES.set(bytes - 1, bytes)
+		mask |= 1 << bitToMaskNext
+		bitToMaskNext--
+	}
+}
+
+module.exports = {
+	makeValueBuffer(value) {
+		assert.integer(value)
+		assert.assert(value >= 0, String(value) + ' is negative')
+		const bytes = (() => {
+			for (const [bytes, maxValue] of UPPER_BOUNDS) {
+				if (maxValue > value) return bytes
+			}
+		})()
+		const writeValue = value - UPPER_BOUNDS.get(bytes - 1)
+		const buffer = new ArrayBuffer(bytes)
+		const castBuffer = new Uint8Array(buffer)
+		{
+			let shiftedValue = writeValue
+			for (let writeByte = bytes - 1; writeByte >= 0; writeByte--) {
+				castBuffer[writeByte] = shiftedValue & 0xFF //write least significant byte
+				shiftedValue >>= 8 //move next least significant byte to least significant byte
+			}
+		}
+		castBuffer[0] |= BYTE_MASKS.get(bytes)
+		return buffer
+	},
+	getByteCount(firstByte) {
+		assert.byteUnsignedInteger(firstByte)
+		const leadingOnes = (() => {
+			let leadingOnes
+			for (leadingOnes = 0; firstByte & 0b10000000; leadingOnes++) {
+				firstByte <<= 1
+			}
+			return leadingOnes
+		})()
+		const bytes = NUMBER_OF_BYTES.get(leadingOnes)
+		assert.assert(bytes !== undefined, 'Invalid number of bytes')
+		return bytes
+	},
+	readValueBuffer(valueBuffer) {
+		assert.instanceOf(valueBuffer, ArrayBuffer)
+		const bytes = valueBuffer.byteLength
+		const castBuffer = new Uint8Array(valueBuffer)
+		const valueOfPossible = (() => {
+			let value = 0
+			for (let byteIndex = 0; byteIndex < bytes; byteIndex++) {
+				value <<= 8
+				value |= castBuffer[byteIndex]
+			}
+			return value ^ (BYTE_MASKS.get(bytes) << ((bytes - 1) * 8))
+		})()
+		return UPPER_BOUNDS.get(bytes - 1) + valueOfPossible
+	}
+}

read.js

@@ -7,6 +7,7 @@ const assert = require(__dirname + '/lib/assert.js')
 const bitMath = require(__dirname + '/lib/bit-math.js')
 const bufferString = require(__dirname + '/lib/buffer-string.js')
 const constructorRegistry = require(__dirname + '/constructor-registry.js')
+const flexInt = require(__dirname + '/lib/flex-int.js')
 const recursiveRegistry = require(__dirname + '/recursive-registry.js')
 const strint = require(__dirname + '/lib/strint.js')
 const t = require(__dirname + '/structure-types.js')
@@ -24,7 +25,7 @@ function readLengthBuffer(buffer, offset) {
 	catch (e) { assert.fail(NOT_LONG_ENOUGH) }
 }
 //Types whose type bytes are only 1 byte long (the type byte)
-const SINGLE_BYTE_TYPES = [
+const SINGLE_BYTE_TYPES = new Set([
 	t.ByteType,
 	t.ShortType,
 	t.IntType,
@@ -35,6 +36,7 @@ const SINGLE_BYTE_TYPES = [
 	t.UnsignedIntType,
 	t.UnsignedLongType,
 	t.BigUnsignedIntType,
+	t.FlexUnsignedIntType,
 	t.DateType,
 	t.DayType,
 	t.TimeType,
@@ -45,7 +47,12 @@ const SINGLE_BYTE_TYPES = [
 	t.CharType,
 	t.StringType,
 	t.OctetsType
-]
+])
+//Mapping of type bytes to the corresponding types
+const SINGLE_BYTE_TYPE_BYTES = new Map
+for (const singleByteType of SINGLE_BYTE_TYPES) {
+	SINGLE_BYTE_TYPE_BYTES.set(singleByteType._value, singleByteType)
+}
 //Pads a string with preceding 0s so that it has the desired length (for error messages)
 function pad(str, digits) {
 	if (str.length < digits) return '0'.repeat(digits - str.length) + str
@@ -154,7 +161,7 @@ function consumeValue({buffer, pointerStart, offset, type, baseValue}) {
 		}
 		case t.UnsignedByteType: {
 			length = 1
-			assert.assert(buffer.byteLength >= offset + length, NOT_LONG_ENOUGH)
+			assert.assert(buffer.byteLength > offset, NOT_LONG_ENOUGH)
 			value = new Uint8Array(buffer)[offset] //endianness doesn't matter because there is only 1 byte
 			break
 		}
@@ -193,6 +200,15 @@ function consumeValue({buffer, pointerStart, offset, type, baseValue}) {
 			length += bytes
 			break
 		}
+		case t.FlexUnsignedIntType: {
+			length = 1
+			assert.assert(buffer.byteLength > offset, NOT_LONG_ENOUGH)
+			const bytes = flexInt.getByteCount(new Uint8Array(buffer)[offset])
+			assert.assert(buffer.byteLength >= offset + bytes, NOT_LONG_ENOUGH)
+			value = flexInt.readValueBuffer(buffer.slice(offset, offset + bytes))
+			length += bytes
+			break
+		}
 		case t.DayType: {
 			length = 3
 			assert.assert(buffer.byteLength >= offset + length, NOT_LONG_ENOUGH)
@@ -412,9 +428,8 @@ function consumeType(typeBuffer, offset) {
 	const typeByte = castBuffer[offset]
 	let value,
 		length = 1
-	for (const testType of SINGLE_BYTE_TYPES) {
-		if (typeByte === testType._value) return {value: new testType, length} //eslint-disable-line new-cap
-	}
+	const singleByteType = SINGLE_BYTE_TYPE_BYTES.get(typeByte)
+	if (singleByteType !== undefined) return {value: new singleByteType, length} //eslint-disable-line new-cap
 	switch (typeByte) {
 		case t.BooleanTupleType._value: {
 			assert.assert(typeBuffer.byteLength > offset + length, NOT_LONG_ENOUGH)

structure-types.js

@@ -10,6 +10,7 @@ const assert = require(__dirname + '/lib/assert.js')
 const base64 = require('base64-js')
 const bufferString = require(__dirname + '/lib/buffer-string.js')
 const config = require(__dirname + '/config.js')
+const flexInt = require(__dirname + '/lib/flex-int.js')
 const sha256 = require('sha256')
 const GrowableBuffer = require(__dirname + '/lib/growable-buffer.js')
 let recursiveRegistry
@@ -533,6 +534,18 @@ class BigUnsignedIntType extends UnsignedType {
 		buffer.addAll(byteBuffer)
 	}
 }
+class FlexUnsignedIntType extends UnsignedType {
+	static get _value() {
+		return 0x17
+	}
+	writeValue(buffer, value) {
+		assert.instanceOf(buffer, GrowableBuffer)
+		const convertedValue = strToNum(value)
+		if (convertedValue !== undefined) value = convertedValue
+		assert.integer(value)
+		buffer.addAll(flexInt.makeValueBuffer(value))
+	}
+}
 
 /**
  * A type storing some sort of time.
@@ -1665,6 +1678,7 @@ module.exports = {
 	UnsignedIntType,
 	UnsignedLongType,
 	BigUnsignedIntType,
+	FlexUnsignedIntType,
 	DateType,
 	DayType,
 	TimeType,

test/type-bytes/flex-unsigned-int.js

@@ -0,0 +1,5 @@
+/*eslint-disable no-undef*/
+const type = new t.FlexUnsignedIntType
+const buffer = type.toBuffer()
+assert.equal(buffer, bufferFrom([0x17]))
+assert.equal(r.type(buffer), new t.FlexUnsignedIntType)

test/value-bytes/flex-unsigned-int.js

@@ -0,0 +1,58 @@
+/*eslint-disable no-undef*/
+const type = new t.FlexUnsignedIntType
+const TWO_7 = Math.pow(2, 7),
+      TWO_14 = Math.pow(2, 14)
+for (let value = 0; value < TWO_7; value++) {
+	const valueBuffer = type.valueBuffer(value)
+	assert.equal(valueBuffer, bufferFrom([value]))
+	assert.equal(r.value({type, buffer: valueBuffer}), value)
+}
+for (let value = TWO_7; value < TWO_7 + TWO_14; value++) {
+	const relativeValue = value - TWO_7
+	const valueBuffer = type.valueBuffer(value)
+	assert.equal(valueBuffer, bufferFrom([
+		0b10000000 | (relativeValue >> 8),
+		relativeValue & 0xFF
+	]))
+	assert.equal(r.value({type, buffer: valueBuffer}), value)
+}
+for (let value = TWO_7 + TWO_14; value < 50000; value++) {
+	const relativeValue = value - (TWO_7 + TWO_14)
+	const valueBuffer = type.valueBuffer(value)
+	assert.equal(valueBuffer, bufferFrom([
+		0b11000000 | (relativeValue >> 16),
+		(relativeValue >> 8) & 0xFF,
+		relativeValue & 0xFF
+	]))
+	assert.equal(r.value({type, buffer: valueBuffer}), value)
+}
+assert.equal(type.valueBuffer('123'), bufferFrom([123]))
+
+assert.throws(
+	() => type.valueBuffer(true),
+	'true is not an instance of Number'
+)
+assert.throws(
+	() => type.valueBuffer(1.2),
+	'1.2 is not an integer'
+)
+assert.throws(
+	() => type.valueBuffer(Number.MAX_SAFE_INTEGER * 2),
+	'18014398509481982 is not an integer'
+)
+assert.throws(
+	() => type.valueBuffer(-1),
+	'-1 is negative'
+)
+assert.throws(
+	() => r.value({type, buffer: bufferFrom([])}),
+	'Buffer is not long enough'
+)
+assert.throws(
+	() => r.value({type, buffer: bufferFrom([0b11111111])}),
+	'Invalid number of bytes'
+)
+assert.throws(
+	() => r.value({type, buffer: bufferFrom([0b10000001])}),
+	'Buffer is not long enough'
+)