Add EnumType

Author: phpnode

src/index.js

@@ -9,6 +9,7 @@ import {make as makeArrayType} from "./type-class/array-type";
 import {make as makeHashMapType} from "./type-class/hash-map-type";
 import {make as makeHashSetType} from "./type-class/hash-set-type";
 import {make as makeUnionType} from "./type-class/union-type";
+import {make as makeEnumType} from "./type-class/enum-type";
 
 import {make as makeStringPool} from "./string-pool";
 
@@ -73,6 +74,7 @@ export class Realm {
     this.HashMapType = makeHashMapType(this);
     this.HashSetType = makeHashSetType(this);
     this.UnionType = makeUnionType(this);
+    this.EnumType = makeEnumType(this);
     this.isInitialized = false;
   }
 
@@ -150,6 +152,11 @@ export class Realm {
     this[$RootHashMap].set(key, value);
     return this;
   }
+
+  delete (key: any): boolean {
+    // @flowIssue 252
+    return this[$RootHashMap].delete(key);
+  }
 }
 
 

src/type-class/README.md

@@ -12,3 +12,5 @@ Builtin Type Classes:
 * [ReferenceType](./reference-type)
 * [StringType](./string-type)
 * [StructType](./struct-type)
+* [EnumType](./enum-type)
+* [UnionType](./union-type)

src/type-class/enum-type/README.md

@@ -0,0 +1,42 @@
+# EnumType
+
+A type class for representing [enumerated values](https://en.wikipedia.org/wiki/Enumerated_type).
+
+Enums efficiently represent a single value out of a predefined set. Unlike most types, they can store *any* kind of value, including symbols and functions. This is because they don't actually store values themselves, instead they store references.
+
+Usage:
+
+```js
+const {EnumType, StructType, T} = realm;
+
+const EmailStatus = new EnumType("read", "unread", "pending", "sent");
+
+const inbox = {
+  name: 'inbox'
+};
+const drafts = {
+  name: 'drafts'
+};
+const outbox = {
+  name: 'outbox'
+};
+const EmailContainer = new EnumType(inbox, drafts, outbox);
+
+const Email = new StructType({
+  subject: T.String,
+  status: EmailStatus,
+  container: EmailContainer,
+  body: T.String
+});
+
+const message = new Email({
+  subject: 'Hello World',
+  status: 'pending',
+  container: drafts,
+  message: 'Hi.'
+});
+
+message.status = 'nope'; // TypeError - not in the list of allowed values.
+message.status = 'sent';
+message.container = outbox;
+```

src/type-class/enum-type/index.js

@@ -0,0 +1,217 @@
+/* @flow */
+
+import Backing from "backing";
+import {inspect} from "util";
+import {TypedObject} from "../";
+import {alignTo} from "../../util";
+
+import type {Realm} from "../../";
+
+import {
+  $ValueType,
+  $Backing,
+  $Address,
+  $CanBeEmbedded,
+  $CanBeReferenced,
+  $CanContainReferences
+} from "../../symbols";
+
+export const MIN_TYPE_ID = Math.pow(2, 20) * 9;
+
+/**
+ * Makes a EnumType type class for the given realm.
+ */
+export function make (realm: Realm): TypeClass<EnumType<any>> {
+  const {TypeClass} = realm;
+  let typeCounter = 0;
+
+  function createTinyEnumType (Enum: Function, possibleValues: Type[]): Object {
+    const name = possibleValues.map(value => inspect(value)).join(' | ');
+    const id = MIN_TYPE_ID + typeCounter;
+    const byteAlignment = 1;
+    const byteLength = 1;
+
+    function enumAccepts (input: any): boolean {
+      const length = possibleValues.length;
+      for (let i = 0; i < length; i++) {
+        if (input === possibleValues[i]) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    function indexFor (value: any): number {
+      const length = possibleValues.length;
+      for (let i = 0; i < length; i++) {
+        if (value === possibleValues[i]) {
+          return i;
+        }
+      }
+      return -1;
+    }
+
+
+    function initializeEnum (backing: Backing, address: float64, initialValue: any): void {
+      let index = indexFor(initialValue);
+      if (index === -1) {
+        if (initialValue === undefined) {
+          index = 0;
+        }
+        else {
+          throw new TypeError(`Enum does not contain the given value: ${inspect(initialValue)}`);
+        }
+      }
+      backing.setUint8(address, index);
+    }
+
+    function storeEnum (backing: Backing, address: float64, value: any): void {
+      const index = indexFor(value);
+      if (index === -1) {
+        throw new TypeError(`Enum does not contain the given value: ${inspect(value)}`);
+      }
+      backing.setUint8(address, index);
+    }
+
+    function loadEnum (backing: Backing, address: float64): any {
+      return possibleValues[backing.getUint8(address)];
+    }
+
+    function clearEnum (backing: Backing, address: float64): void {
+      backing.setUint8(address, 0);
+    }
+
+    function enumDestructor (backing: Backing, address: float64): void {
+      // no-op
+    }
+
+    return {
+      id,
+      name,
+      byteLength,
+      byteAlignment,
+      accepts: enumAccepts,
+      initialize: initializeEnum,
+      store: storeEnum,
+      load: loadEnum,
+      clear: clearEnum,
+      destructor: enumDestructor,
+      emptyValue (): any {
+        return possibleValues[0];
+      },
+      randomValue (): any {
+        return possibleValues[Math.floor(Math.random() * possibleValues.length)];
+      }
+    };
+
+  }
+
+  function createLargeEnumType (Enum: Function, possibleValues: Type[]): Object {
+    const name = possibleValues.map(value => inspect(value)).join(' | ');
+    const id = MIN_TYPE_ID + typeCounter;
+    const byteAlignment = 2;
+    const byteLength = 2;
+    const valueMap = new Map(possibleValues.map((value, index) => [value, index]));
+
+    function enumAccepts (input: any): boolean {
+      return valueMap.has(input);
+    }
+
+    function indexFor (value: any): number {
+      const index = valueMap.get(value);
+      if (typeof index === 'number') {
+        return index;
+      }
+      else {
+        return -1;
+      }
+    }
+
+
+    function initializeEnum (backing: Backing, address: float64, initialValue: any): void {
+      let index = indexFor(initialValue);
+      if (index === -1) {
+        if (initialValue === undefined) {
+          index = 0;
+        }
+        else {
+          throw new TypeError(`Enum does not contain the given value: ${inspect(initialValue)}`);
+        }
+      }
+      backing.setUint16(address, index);
+    }
+
+    function storeEnum (backing: Backing, address: float64, value: any): void {
+      const index = indexFor(value);
+      if (index === -1) {
+        throw new TypeError(`Enum does not contain the given value: ${inspect(value)}`);
+      }
+      backing.setUint16(address, index);
+    }
+
+    function loadEnum (backing: Backing, address: float64): any {
+      return possibleValues[backing.getUint16(address)];
+    }
+
+    function clearEnum (backing: Backing, address: float64): void {
+      backing.setUint16(address, 0);
+    }
+
+    function enumDestructor (backing: Backing, address: float64): void {
+      // no-op
+    }
+
+    return {
+      id,
+      name,
+      byteLength,
+      byteAlignment,
+      accepts: enumAccepts,
+      initialize: initializeEnum,
+      store: storeEnum,
+      load: loadEnum,
+      clear: clearEnum,
+      destructor: enumDestructor,
+      emptyValue (): any {
+        return possibleValues[0];
+      },
+      randomValue (): any {
+        return possibleValues[Math.floor(Math.random() * possibleValues.length)];
+      }
+    };
+
+  }
+
+  return new TypeClass('EnumType', (...possibleValues: Type[]) => {
+    return (Enum: Function): Object => {
+      typeCounter++;
+
+      let EnumArray;
+      // @flowIssue 285
+      Object.defineProperties(Enum, {
+        Array: {
+          get () {
+            if (EnumArray === undefined) {
+              EnumArray = new realm.ArrayType(Enum);
+            }
+            return EnumArray;
+          }
+        }
+      });
+
+      Enum[$CanBeEmbedded] = true;
+      Enum[$CanBeReferenced] = false;
+      Enum[$CanContainReferences] = false;
+
+      if (possibleValues.length >= Math.pow(2, 16)) {
+        throw new RangeError(`Enum can only store up to ${Math.pow(2, 16)} values.`);
+      }
+      else if (possibleValues.length >= 256) {
+        return createLargeEnumType(Enum, possibleValues);
+      }
+      else {
+        return createTinyEnumType(Enum, possibleValues);
+      }
+    };
+  });
+};