Fixed #63

Author: calebsander

dist/types/enum.d.ts

@@ -33,14 +33,15 @@ export default class EnumType<E> extends AbstractType<E> {
      */
     readonly values: E[];
     private readonly type;
-    private readonly valueIndices;
+    private cachedValueIndices;
     /**
      * @param type The type of each element in the tuple
      * @param values The possible distinct values.
      * Cannot contain more than 255 values.
      * @throws If any value cannot be serialized by `type`
      */
     constructor({ type, values }: EnumParams<E>);
+    private readonly valueIndices;
     addToBuffer(buffer: AppendableBuffer): boolean;
     /**
      * Appends value bytes to an [[AppendableBuffer]] according to the type

dist/types/enum.js

@@ -44,6 +44,16 @@ class EnumType extends abstract_1.default {
         catch (e) {
             assert_1.default.fail(String(values.length) + ' values is too many');
         }
+        this.type = type;
+        this.values = values; //used when reading to get constant-time lookup of value index into value
+    }
+    static get _value() {
+        return 0x55;
+    }
+    get valueIndices() {
+        const { type, values, cachedValueIndices } = this;
+        if (cachedValueIndices)
+            return cachedValueIndices;
         const valueIndices = new Map();
         for (let i = 0; i < values.length; i++) {
             const value = values[i];
@@ -52,18 +62,13 @@ class EnumType extends abstract_1.default {
                 assert_1.default.fail('Value is repeated: ' + util_inspect_1.inspect(value));
             valueIndices.set(valueString, i); //so writing a value has constant-time lookup into the values array
         }
-        this.type = type;
-        this.values = values; //used when reading to get constant-time lookup of value index into value
-        this.valueIndices = valueIndices;
-    }
-    static get _value() {
-        return 0x55;
+        return this.cachedValueIndices = valueIndices;
     }
     addToBuffer(buffer) {
         /*istanbul ignore else*/
         if (super.addToBuffer(buffer)) {
             this.type.addToBuffer(buffer);
-            buffer.add(this.valueIndices.size);
+            buffer.add(this.values.length);
             for (const valueBuffer of this.valueIndices.keys()) {
                 buffer.addAll(bufferString.fromBinaryString(valueBuffer));
             }
@@ -94,13 +99,10 @@ class EnumType extends abstract_1.default {
     consumeValue(buffer, offset) {
         assert_1.default(buffer.byteLength > offset, read_util_1.NOT_LONG_ENOUGH);
         const valueIndex = new Uint8Array(buffer)[offset];
-        //Can't check for value === undefined since value could be undefined with OptionalType
-        const { values } = this;
-        assert_1.default(valueIndex in values, 'Index ' + String(valueIndex) + ' is invalid');
-        return {
-            value: values[valueIndex],
-            length: 1
-        };
+        const value = this.values[valueIndex];
+        if (value === undefined)
+            throw new Error('Index ' + String(valueIndex) + ' is invalid');
+        return { value, length: 1 };
     }
     equals(otherType) {
         if (!super.equals(otherType))

test/type-bytes/enum.ts

@@ -16,12 +16,10 @@ export = () => {
 		[tooManyValues, '256 values is too many']
 	]) {
 		assert.throws(
-			() => {
-				new t.EnumType({
-					type: new t.StringType,
-					values: invalidValues as any
-				})
-			},
+			() => new t.EnumType({
+				type: new t.StringType,
+				values: invalidValues as any
+			}).toBuffer(),
 			message as string
 		)
 	}

types/enum.ts

@@ -40,7 +40,7 @@ export default class EnumType<E> extends AbstractType<E> {
 	 */
 	readonly values: E[]
 	private readonly type: Type<E>
-	private readonly valueIndices: Map<string, number>
+	private cachedValueIndices: Map<string, number> | undefined
 	/**
 	 * @param type The type of each element in the tuple
 	 * @param values The possible distinct values.
@@ -55,22 +55,27 @@ export default class EnumType<E> extends AbstractType<E> {
 		try { assert.byteUnsignedInteger(values.length) }
 		catch (e) { assert.fail(String(values.length) + ' values is too many') }
 
+		this.type = type
+		this.values = values //used when reading to get constant-time lookup of value index into value
+	}
+	private get valueIndices() {
+		const {type, values, cachedValueIndices} = this
+		if (cachedValueIndices) return cachedValueIndices
+
 		const valueIndices = new Map<string, number>()
 		for (let i = 0; i < values.length; i++) {
 			const value = values[i]
 			const valueString = bufferString.toBinaryString(type.valueBuffer(value)) //convert value to bytes and then string for use as a map key
 			if (valueIndices.has(valueString)) assert.fail('Value is repeated: ' + inspect(value))
 			valueIndices.set(valueString, i) //so writing a value has constant-time lookup into the values array
 		}
-		this.type = type
-		this.values = values //used when reading to get constant-time lookup of value index into value
-		this.valueIndices = valueIndices
+		return this.cachedValueIndices = valueIndices
 	}
 	addToBuffer(buffer: AppendableBuffer) {
 		/*istanbul ignore else*/
 		if (super.addToBuffer(buffer)) {
 			this.type.addToBuffer(buffer)
-			buffer.add(this.valueIndices.size)
+			buffer.add(this.values.length)
 			for (const valueBuffer of this.valueIndices.keys()) {
 				buffer.addAll(bufferString.fromBinaryString(valueBuffer))
 			}
@@ -100,13 +105,9 @@ export default class EnumType<E> extends AbstractType<E> {
 	consumeValue(buffer: ArrayBuffer, offset: number): ReadResult<E> {
 		assert(buffer.byteLength > offset, NOT_LONG_ENOUGH)
 		const valueIndex = new Uint8Array(buffer)[offset]
-		//Can't check for value === undefined since value could be undefined with OptionalType
-		const {values} = this
-		assert(valueIndex in values, 'Index ' + String(valueIndex) + ' is invalid')
-		return {
-			value: values[valueIndex],
-			length: 1
-		}
+		const value = this.values[valueIndex] as E | undefined
+		if (value === undefined) throw new Error('Index ' + String(valueIndex) + ' is invalid')
+		return {value, length: 1}
 	}
 	equals(otherType: any) {
 		if (!super.equals(otherType)) return false