Implement alternate storage strategies.

The following storage strategies exist and are used from the `Stack`
implementation:

* `ListCache`
* `Hash`
* `MapCache`

`ListCache`
===========

This is the initial storage mechanism. The underlying data format
is as follows:

```js
[
  [key, value]
  [key, value]
  [key, value]
  [key, value]
]
```

`Hash`
======

The underlying data format is as follows:

```js
{
  [key]: value
}
```

The base object is an `EmptyObject` (roughly `Object.create(null)`).

`MapCache`
==========

`MapCache` defers to different underlying storage mechanisms based on
the key being stored:

* `string` -- Utilizes a `Hash` dedicated to string keys.
* `number` / `symbol` / `boolean` -- Utilizes a dedicated `Hash` for
  these types (all are stored in the same `Hash`).
* Everything else falls back to using `ListCache`.

---

The overall strategy is to store items in the `ListCache` until it has
200 items in it, then we translate from `ListCache` to `MapCache` (which
actually uses 3 different structures internally depending on which
object type is being used as a key).

All credit to this mechanism goes to Lodash, they did incredible work
here and we are just utilizing their mechanisms. Once the performance of
this within Ember is validated, we will migrate away from this locally
vendored version of this file and simply use a stripped version of
`lodash` itself from the build.

Author: rwjblue

packages/ember-metal/lib/utils/lodash-stack.js

@@ -1,5 +1,10 @@
+// jshint eqeqeq:false
+// jshint laxbreak:true
+
+import EmptyObject from '../empty_object';
+
 /*
- From Lodash's private ListCache here:
+ From Lodash's private Stack/Hash/MapCache/ListCache here:
 
  https://github.com/lodash/lodash/blob/4.13.1/dist/lodash.js#L1790-L1900
 
@@ -16,6 +21,24 @@
  ***********************************************************************
 
 */
+
+const LARGE_ARRAY_SIZE = 200;
+const HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+function isKeyable(value) {
+  var type = typeof value;
+  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+    ? (value !== '__proto__')
+    : (value === null);
+}
+
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key)
+    ? data[typeof key == 'string' ? 'string' : 'hash']
+  : data.map;
+}
+
 function assocIndexOf(array, key) {
   var length = array.length;
   while (length--) {
@@ -27,9 +50,108 @@ function assocIndexOf(array, key) {
   return -1;
 }
 
-export default class ListCache {
-  constructor() {
-    this.__data__ = [];
+export class Hash {
+  constructor(entries) {
+    let index = -1;
+    let length = entries ? entries.length : 0;
+
+    this.clear();
+
+    while (++index < length) {
+      let entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  clear() {
+    this.__data__ = new EmptyObject();
+  }
+
+  delete(key) {
+    return this.has(key) && delete this.__data__[key];
+  }
+
+  get(key) {
+    let data = this.__data__;
+    let result = data[key];
+
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+
+  has(key) {
+    let data = this.__data__;
+    return data[key] !== undefined;
+  }
+
+  set(key, value) {
+    var data = this.__data__;
+    data[key] = value === undefined ? HASH_UNDEFINED : value;
+  }
+
+  forEach(callback) {
+    let data = this.__data__;
+    for (let key in data) {
+      callback(key, data[key]);
+    }
+  }
+}
+
+export class MapCache {
+  constructor(entries) {
+    let index = -1;
+    let length = entries ? entries.length : 0;
+
+    this.clear();
+
+    while (++index < length) {
+      let entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  clear() {
+    this.__data__ = {
+      'hash': new Hash(),
+      // TODO: use native Map if present
+      'map': new ListCache(),
+      'string': new Hash()
+    };
+  }
+
+  delete(key) {
+    return getMapData(this, key)['delete'](key);
+  }
+
+  get(key) {
+    return getMapData(this, key).get(key);
+  }
+
+  has(key) {
+    return getMapData(this, key).has(key);
+  }
+
+  set(key, value) {
+    getMapData(this, key).set(key, value);
+  }
+
+  forEach(callback) {
+    this.__data__.hash.forEach(callback);
+    this.__data__.map.forEach(callback);
+    this.__data__.string.forEach(callback);
+  }
+}
+
+export class ListCache {
+  constructor(entries) {
+    let index = -1;
+    let length = entries ? entries.length : 0;
+
+    this.clear();
+
+    while (++index < length) {
+      let entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
   }
 
   clear() {
@@ -44,7 +166,7 @@ export default class ListCache {
       return false;
     }
     var lastIndex = data.length - 1;
-    if (index == lastIndex) {     // jshint ignore:line
+    if (index == lastIndex) {
       data.pop();
     } else {
       data.splice(index, 1);
@@ -73,14 +195,8 @@ export default class ListCache {
     } else {
       data[index][1] = value;
     }
-
-    return this;
   }
 
-  /*
-   This is not included in the lodash ListCache/Stack interface
-   but is required to support all the operations of Meta.
-   */
   forEach(callback) {
     let index = -1;
 
@@ -89,3 +205,41 @@ export default class ListCache {
     }
   }
 }
+
+export default class Stack {
+  constructor() {
+    this.__data__ = new ListCache();
+  }
+
+  clear() {
+    this.__data__ = new ListCache();
+  }
+
+  delete(key) {
+    return this.__data__.delete(key);
+  }
+
+  get(key) {
+    return this.__data__.get(key);
+  }
+
+  has(key) {
+    return this.__data__.has(key);
+  }
+
+  set(key, value) {
+    let cache = this.__data__;
+    if (cache instanceof ListCache && cache.__data__.length == LARGE_ARRAY_SIZE) {
+      cache = this.__data__ = new MapCache(cache.__data__);
+    }
+    cache.set(key, value);
+  }
+
+  /*
+   This is not included in the lodash Stack interface
+   but is required to support all the operations of Meta.
+   */
+  forEach(callback) {
+    this.__data__.forEach(callback);
+  }
+}