Adding float-no-zero branch hosted build

float-no-zero/closure-library/closure/goog/labs/structs/map.js

@@ -0,0 +1,339 @@
+// Copyright 2012 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview A map data structure that offers a convenient API to
+ * manipulate a key, value map. The key must be a string.
+ *
+ * This implementation also ensure that you can use keys that would
+ * not be usable using a normal object literal {}. Some examples
+ * include __proto__ (all newer browsers), toString/hasOwnProperty (IE
+ * <= 8).
+ */
+
+goog.provide('goog.labs.structs.Map');
+
+goog.require('goog.array');
+goog.require('goog.asserts');
+goog.require('goog.labs.object');
+goog.require('goog.object');
+
+
+
+/**
+ * Creates a new map.
+ * @constructor
+ */
+goog.labs.structs.Map = function() {
+  // clear() initializes the map to the empty state.
+  this.clear();
+};
+
+
+/**
+ * @type {function(this: Object, string): boolean}
+ * @private
+ */
+goog.labs.structs.Map.objectPropertyIsEnumerable_ =
+    Object.prototype.propertyIsEnumerable;
+
+
+/**
+ * @type {function(this: Object, string): boolean}
+ * @private
+ */
+goog.labs.structs.Map.objectHasOwnProperty_ =
+    Object.prototype.hasOwnProperty;
+
+
+/**
+ * Primary backing store of this map.
+ * @type {!Object}
+ * @private
+ */
+goog.labs.structs.Map.prototype.map_;
+
+
+/**
+ * Secondary backing store for keys. The index corresponds to the
+ * index for secondaryStoreValues_.
+ * @type {!Array.<string>}
+ * @private
+ */
+goog.labs.structs.Map.prototype.secondaryStoreKeys_;
+
+
+/**
+ * Secondary backing store for keys. The index corresponds to the
+ * index for secondaryStoreValues_.
+ * @type {!Array.<*>}
+ * @private
+ */
+goog.labs.structs.Map.prototype.secondaryStoreValues_;
+
+
+/**
+ * Adds the (key, value) pair, overriding previous entry with the same
+ * key, if any.
+ * @param {string} key The key.
+ * @param {*} value The value.
+ */
+goog.labs.structs.Map.prototype.set = function(key, value) {
+  this.assertKeyIsString_(key);
+
+  var newKey = !this.hasKeyInPrimaryStore_(key);
+  this.map_[key] = value;
+
+  // __proto__ is not settable on object.
+  if (key == '__proto__' ||
+      // Shadows for built-in properties are not enumerable in IE <= 8 .
+      (!goog.labs.structs.Map.BrowserFeature.OBJECT_CREATE_SUPPORTED &&
+       !goog.labs.structs.Map.objectPropertyIsEnumerable_.call(
+           this.map_, key))) {
+    delete this.map_[key];
+    var index = goog.array.indexOf(this.secondaryStoreKeys_, key);
+    if ((newKey = index < 0)) {
+      index = this.secondaryStoreKeys_.length;
+    }
+
+    this.secondaryStoreKeys_[index] = key;
+    this.secondaryStoreValues_[index] = value;
+  }
+
+  if (newKey) this.count_++;
+};
+
+
+/**
+ * Gets the value for the given key.
+ * @param {string} key The key whose value we want to retrieve.
+ * @param {*=} opt_default The default value to return if the key does
+ *     not exist in the map, default to undefined.
+ * @return {*} The value corresponding to the given key, or opt_default
+ *     if the key does not exist in this map.
+ */
+goog.labs.structs.Map.prototype.get = function(key, opt_default) {
+  this.assertKeyIsString_(key);
+
+  if (this.hasKeyInPrimaryStore_(key)) {
+    return this.map_[key];
+  }
+
+  var index = goog.array.indexOf(this.secondaryStoreKeys_, key);
+  return index >= 0 ? this.secondaryStoreValues_[index] : opt_default;
+};
+
+
+/**
+ * Removes the map entry with the given key.
+ * @param {string} key The key to remove.
+ * @return {boolean} True if the entry is removed.
+ */
+goog.labs.structs.Map.prototype.remove = function(key) {
+  this.assertKeyIsString_(key);
+
+  if (this.hasKeyInPrimaryStore_(key)) {
+    this.count_--;
+    delete this.map_[key];
+    return true;
+  } else {
+    var index = goog.array.indexOf(this.secondaryStoreKeys_, key);
+    if (index >= 0) {
+      this.count_--;
+      goog.array.removeAt(this.secondaryStoreKeys_, index);
+      goog.array.removeAt(this.secondaryStoreValues_, index);
+      return true;
+    }
+  }
+  return false;
+};
+
+
+/**
+ * Adds the content of the map to this map. If a new entry uses a key
+ * that already exists in this map, the existing key is replaced.
+ * @param {!goog.labs.structs.Map} map The map to add.
+ */
+goog.labs.structs.Map.prototype.addAll = function(map) {
+  goog.array.forEach(map.getKeys(), function(key) {
+    this.set(key, map.get(key));
+  }, this);
+};
+
+
+/**
+ * @return {boolean} True if the map is empty.
+ */
+goog.labs.structs.Map.prototype.isEmpty = function() {
+  return !this.count_;
+};
+
+
+/**
+ * @return {number} The number of the entries in this map.
+ */
+goog.labs.structs.Map.prototype.getCount = function() {
+  return this.count_;
+};
+
+
+/**
+ * @param {string} key The key to check.
+ * @return {boolean} True if the map contains the given key.
+ */
+goog.labs.structs.Map.prototype.containsKey = function(key) {
+  this.assertKeyIsString_(key);
+  return this.hasKeyInPrimaryStore_(key) ||
+      goog.array.contains(this.secondaryStoreKeys_, key);
+};
+
+
+/**
+ * Whether the map contains the given value. The comparison is done
+ * using !== comparator. Also returns true if the passed value is NaN
+ * and a NaN value exists in the map.
+ * @param {*} value Value to check.
+ * @return {boolean} True if the map contains the given value.
+ */
+goog.labs.structs.Map.prototype.containsValue = function(value) {
+  var found = goog.object.some(this.map_, function(v, k) {
+    return this.hasKeyInPrimaryStore_(k) &&
+        goog.labs.object.is(v, value);
+  }, this);
+  return found || goog.array.contains(this.secondaryStoreValues_, value);
+};
+
+
+/**
+ * @return {!Array.<string>} An array of all the keys contained in this map.
+ */
+goog.labs.structs.Map.prototype.getKeys = function() {
+  var keys;
+  if (goog.labs.structs.Map.BrowserFeature.OBJECT_KEYS_SUPPORTED) {
+    keys = goog.array.clone(Object.keys(this.map_));
+  } else {
+    keys = [];
+    for (var key in this.map_) {
+      if (goog.labs.structs.Map.objectHasOwnProperty_.call(this.map_, key)) {
+        keys.push(key);
+      }
+    }
+  }
+
+  goog.array.extend(keys, this.secondaryStoreKeys_);
+  return keys;
+};
+
+
+/**
+ * @return {!Array.<*>} An array of all the values contained in this map.
+ *     There may be duplicates.
+ */
+goog.labs.structs.Map.prototype.getValues = function() {
+  var values = [];
+  var keys = this.getKeys();
+  for (var i = 0; i < keys.length; i++) {
+    values.push(this.get(keys[i]));
+  }
+  return values;
+};
+
+
+/**
+ * @return {!Array.<Array>} An array of entries. Each entry is of the
+ *     form [key, value]. Do not rely on consistent ordering of entries.
+ */
+goog.labs.structs.Map.prototype.getEntries = function() {
+  var entries = [];
+  var keys = this.getKeys();
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    entries.push([key, this.get(key)]);
+  }
+  return entries;
+};
+
+
+/**
+ * Clears the map to the initial state.
+ */
+goog.labs.structs.Map.prototype.clear = function() {
+  this.map_ = goog.labs.structs.Map.BrowserFeature.OBJECT_CREATE_SUPPORTED ?
+      Object.create(null) : {};
+  this.secondaryStoreKeys_ = [];
+  this.secondaryStoreValues_ = [];
+  this.count_ = 0;
+};
+
+
+/**
+ * Clones this map.
+ * @return {!goog.labs.structs.Map} The clone of this map.
+ */
+goog.labs.structs.Map.prototype.clone = function() {
+  var map = new goog.labs.structs.Map();
+  map.addAll(this);
+  return map;
+};
+
+
+/**
+ * @param {string} key The key to check.
+ * @return {boolean} True if the given key has been added successfully
+ *     to the primary store.
+ * @private
+ */
+goog.labs.structs.Map.prototype.hasKeyInPrimaryStore_ = function(key) {
+  // New browsers that support Object.create do not allow setting of
+  // __proto__. In other browsers, hasOwnProperty will return true for
+  // __proto__ for object created with literal {}, so we need to
+  // special case it.
+  if (key == '__proto__') {
+    return false;
+  }
+
+  if (goog.labs.structs.Map.BrowserFeature.OBJECT_CREATE_SUPPORTED) {
+    return key in this.map_;
+  }
+
+  return goog.labs.structs.Map.objectHasOwnProperty_.call(this.map_, key);
+};
+
+
+/**
+ * Asserts that the given key is a string.
+ * @param {string} key The key to check.
+ * @private
+ */
+goog.labs.structs.Map.prototype.assertKeyIsString_ = function(key) {
+  goog.asserts.assert(goog.isString(key), 'key must be a string.');
+};
+
+
+/**
+ * Browser feature enum necessary for map.
+ * @enum {boolean}
+ */
+goog.labs.structs.Map.BrowserFeature = {
+  // TODO(user): Replace with goog.userAgent detection.
+  /**
+   * Whether Object.create method is supported.
+   */
+  OBJECT_CREATE_SUPPORTED: !!Object.create,
+
+  /**
+   * Whether Object.keys method is supported.
+   */
+  OBJECT_KEYS_SUPPORTED: !!Object.keys
+};

float-no-zero/closure-library/closure/goog/labs/structs/map_perf.js

@@ -0,0 +1,201 @@
+// Copyright 2012 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Performance test for goog.structs.Map and
+ * goog.labs.structs.Map. To run this test fairly, you would have to
+ * compile this via JsCompiler (with --export_test_functions), and
+ * pull the compiled JS into an empty HTML file.
+ */
+
+goog.provide('goog.labs.structs.mapPerf');
+
+goog.require('goog.dom');
+goog.require('goog.labs.structs.Map');
+goog.require('goog.structs.Map');
+goog.require('goog.testing.PerformanceTable');
+goog.require('goog.testing.jsunit');
+
+goog.scope(function() {
+var mapPerf = goog.labs.structs.mapPerf;
+
+
+/**
+ * @typedef {goog.labs.structs.Map|goog.structs.Map}
+ */
+mapPerf.MapType;
+
+
+/**
+ * @type {goog.testing.PerformanceTable}
+ */
+mapPerf.perfTable;
+
+
+/**
+ * A key list. This maps loop index to key name to be used during
+ * benchmark. This ensure that we do not need to pay the cost of
+ * string concatenation/GC whenever we derive a key from loop index.
+ *
+ * This is filled once in setUpPage and then remain unchanged for the
+ * rest of the test case.
+ *
+ * @type {Array}
+ */
+mapPerf.keyList = [];
+
+
+/**
+ * Maxium number of keys in keyList (and, by extension, the map under
+ * test).
+ * @type {number}
+ */
+mapPerf.MAX_NUM_KEY = 10000;
+
+
+/**
+ * Fills the given map with generated key-value pair.
+ * @param {mapPerf.MapType} map The map to fill.
+ * @param {number} numKeys The number of key-value pair to fill.
+ */
+mapPerf.fillMap = function(map, numKeys) {
+  goog.asserts.assert(numKeys <= mapPerf.MAX_NUM_KEY);
+
+  for (var i = 0; i < numKeys; ++i) {
+    map.set(mapPerf.keyList[i], i);
+  }
+};
+
+
+/**
+ * Primes the given map with deletion of keys.
+ * @param {mapPerf.MapType} map The map to prime.
+ * @return {mapPerf.MapType} The primed map (for chaining).
+ */
+mapPerf.primeMapWithDeletion = function(map) {
+  for (var i = 0; i < 1000; ++i) {
+    map.set(mapPerf.keyList[i], i);
+  }
+  for (var i = 0; i < 1000; ++i) {
+    map.remove(mapPerf.keyList[i]);
+  }
+  return map;
+};
+
+
+/**
+ * Runs performance test for Map#get with the given map.
+ * @param {mapPerf.MapType} map The map to stress.
+ * @param {string} message Message to be put in performance table.
+ */
+mapPerf.runPerformanceTestForMapGet = function(map, message) {
+  mapPerf.fillMap(map, 10000);
+
+  mapPerf.perfTable.run(
+      function() {
+        // Creates local alias for map and keyList.
+        var localMap = map;
+        var localKeyList = mapPerf.keyList;
+
+        for (var i = 0; i < 500; ++i) {
+          var sum = 0;
+          for (var j = 0; j < 10000; ++j) {
+            sum += localMap.get(localKeyList[j]);
+          }
+        }
+      },
+      message);
+};
+
+
+/**
+ * Runs performance test for Map#set with the given map.
+ * @param {mapPerf.MapType} map The map to stress.
+ * @param {string} message Message to be put in performance table.
+ */
+mapPerf.runPerformanceTestForMapSet = function(map, message) {
+  mapPerf.perfTable.run(
+      function() {
+        // Creates local alias for map and keyList.
+        var localMap = map;
+        var localKeyList = mapPerf.keyList;
+
+        for (var i = 0; i < 500; ++i) {
+          for (var j = 0; j < 10000; ++j) {
+            localMap.set(localKeyList[i], i);
+          }
+        }
+      },
+      message);
+};
+
+
+goog.global['setUpPage'] = function() {
+  var content = goog.dom.createDom('div');
+  goog.dom.insertChildAt(document.body, content, 0);
+  var ua = navigator.userAgent;
+  content.innerHTML =
+      '<h1>Closure Performance Tests - Map</h1>' +
+      '<p><strong>User-agent: </strong><span id="ua">' + ua + '</span></p>' +
+      '<div id="perf-table"></div>' +
+      '<hr>';
+
+  mapPerf.perfTable = new goog.testing.PerformanceTable(
+      goog.dom.getElement('perf-table'));
+
+  // Fills keyList.
+  for (var i = 0; i < mapPerf.MAX_NUM_KEY; ++i) {
+    mapPerf.keyList.push('k' + i);
+  }
+};
+
+
+goog.global['testGetFromLabsMap'] = function() {
+  mapPerf.runPerformanceTestForMapGet(
+      new goog.labs.structs.Map(), '#get: no previous deletion (Labs)');
+};
+
+
+goog.global['testGetFromOriginalMap'] = function() {
+  mapPerf.runPerformanceTestForMapGet(
+      new goog.structs.Map(), '#get: no previous deletion (Original)');
+};
+
+
+goog.global['testGetWithPreviousDeletionFromLabsMap'] = function() {
+  mapPerf.runPerformanceTestForMapGet(
+      mapPerf.primeMapWithDeletion(new goog.labs.structs.Map()),
+      '#get: with previous deletion (Labs)');
+};
+
+
+goog.global['testGetWithPreviousDeletionFromOriginalMap'] = function() {
+  mapPerf.runPerformanceTestForMapGet(
+      mapPerf.primeMapWithDeletion(new goog.structs.Map()),
+      '#get: with previous deletion (Original)');
+};
+
+
+goog.global['testSetFromLabsMap'] = function() {
+  mapPerf.runPerformanceTestForMapSet(
+      new goog.labs.structs.Map(), '#set: no previous deletion (Labs)');
+};
+
+
+goog.global['testSetFromOriginalMap'] = function() {
+  mapPerf.runPerformanceTestForMapSet(
+      new goog.structs.Map(), '#set: no previous deletion (Original)');
+};
+
+});  // goog.scope

float-no-zero/closure-library/closure/goog/labs/structs/multimap.js

@@ -0,0 +1,279 @@
+// Copyright 2012 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview A collection similar to
+ * {@code goog.labs.structs.Map}, but also allows associating multiple
+ * values with a single key.
+ *
+ * This implementation ensures that you can use any string keys.
+ *
+ */
+
+goog.provide('goog.labs.structs.Multimap');
+
+goog.require('goog.array');
+goog.require('goog.labs.object');
+goog.require('goog.labs.structs.Map');
+
+
+
+/**
+ * Creates a new multimap.
+ * @constructor
+ */
+goog.labs.structs.Multimap = function() {
+  this.clear();
+};
+
+
+/**
+ * The backing map.
+ * @type {!goog.labs.structs.Map}
+ * @private
+ */
+goog.labs.structs.Multimap.prototype.map_;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+goog.labs.structs.Multimap.prototype.count_ = 0;
+
+
+/**
+ * Clears the multimap.
+ */
+goog.labs.structs.Multimap.prototype.clear = function() {
+  this.count_ = 0;
+  this.map_ = new goog.labs.structs.Map();
+};
+
+
+/**
+ * Clones this multimap.
+ * @return {!goog.labs.structs.Multimap} A multimap that contains all
+ *     the mapping this multimap has.
+ */
+goog.labs.structs.Multimap.prototype.clone = function() {
+  var map = new goog.labs.structs.Multimap();
+  map.addAllFromMultimap(this);
+  return map;
+};
+
+
+/**
+ * Adds the given (key, value) pair to the map. The (key, value) pair
+ * is guaranteed to be added.
+ * @param {string} key The key to add.
+ * @param {*} value The value to add.
+ */
+goog.labs.structs.Multimap.prototype.add = function(key, value) {
+  var values = this.map_.get(key);
+  if (!values) {
+    this.map_.set(key, (values = []));
+  }
+
+  values.push(value);
+  this.count_++;
+};
+
+
+/**
+ * Stores a collection of values to the given key. Does not replace
+ * existing (key, value) pairs.
+ * @param {string} key The key to add.
+ * @param {!Array.<*>} values The values to add.
+ */
+goog.labs.structs.Multimap.prototype.addAllValues = function(key, values) {
+  goog.array.forEach(values, function(v) {
+    this.add(key, v);
+  }, this);
+};
+
+
+/**
+ * Adds the contents of the given map/multimap to this multimap.
+ * @param {!(goog.labs.structs.Map|goog.labs.structs.Multimap)} map The
+ *     map to add.
+ */
+goog.labs.structs.Multimap.prototype.addAllFromMultimap = function(map) {
+  goog.array.forEach(map.getEntries(), function(entry) {
+    this.add(entry[0], entry[1]);
+  }, this);
+};
+
+
+/**
+ * Replaces all the values for the given key with the given values.
+ * @param {string} key The key whose values are to be replaced.
+ * @param {!Array.<*>} values The new values. If empty, this is
+ *     equivalent to {@code removaAll(key)}.
+ */
+goog.labs.structs.Multimap.prototype.replaceValues = function(key, values) {
+  this.removeAll(key);
+  this.addAllValues(key, values);
+};
+
+
+/**
+ * Gets the values correspond to the given key.
+ * @param {string} key The key to retrieve.
+ * @return {!Array.<*>} An array of values corresponding to the given
+ *     key. May be empty. Note that the ordering of values are not
+ *     guaranteed to be consistent.
+ */
+goog.labs.structs.Multimap.prototype.get = function(key) {
+  var values = /** @type {Array.<string>} */ (this.map_.get(key));
+  return values ? goog.array.clone(values) : [];
+};
+
+
+/**
+ * Removes a single occurrence of (key, value) pair.
+ * @param {string} key The key to remove.
+ * @param {*} value The value to remove.
+ * @return {boolean} Whether any matching (key, value) pair is removed.
+ */
+goog.labs.structs.Multimap.prototype.remove = function(key, value) {
+  var values = /** @type {Array.<string>} */ (this.map_.get(key));
+  if (!values) {
+    return false;
+  }
+
+  var removed = goog.array.removeIf(values, function(v) {
+    return goog.labs.object.is(value, v);
+  });
+
+  if (removed) {
+    this.count_--;
+    if (values.length == 0) {
+      this.map_.remove(key);
+    }
+  }
+  return removed;
+};
+
+
+/**
+ * Removes all values corresponding to the given key.
+ * @param {string} key The key whose values are to be removed.
+ * @return {boolean} Whether any value is removed.
+ */
+goog.labs.structs.Multimap.prototype.removeAll = function(key) {
+  // We have to first retrieve the values from the backing map because
+  // we need to keep track of count (and correctly calculates the
+  // return value). values may be undefined.
+  var values = this.map_.get(key);
+  if (this.map_.remove(key)) {
+    this.count_ -= values.length;
+    return true;
+  }
+
+  return false;
+};
+
+
+/**
+ * @return {boolean} Whether the multimap is empty.
+ */
+goog.labs.structs.Multimap.prototype.isEmpty = function() {
+  return !this.count_;
+};
+
+
+/**
+ * @return {number} The count of (key, value) pairs in the map.
+ */
+goog.labs.structs.Multimap.prototype.getCount = function() {
+  return this.count_;
+};
+
+
+/**
+ * @param {string} key The key to check.
+ * @param {string} value The value to check.
+ * @return {boolean} Whether the (key, value) pair exists in the multimap.
+ */
+goog.labs.structs.Multimap.prototype.containsEntry = function(key, value) {
+  var values = /** @type {Array.<string>} */ (this.map_.get(key));
+  if (!values) {
+    return false;
+  }
+
+  var index = goog.array.findIndex(values, function(v) {
+    return goog.labs.object.is(v, value);
+  });
+  return index >= 0;
+};
+
+
+/**
+ * @param {string} key The key to check.
+ * @return {boolean} Whether the multimap contains at least one (key,
+ *     value) pair with the given key.
+ */
+goog.labs.structs.Multimap.prototype.containsKey = function(key) {
+  return this.map_.containsKey(key);
+};
+
+
+/**
+ * @param {*} value The value to check.
+ * @return {boolean} Whether the multimap contains at least one (key,
+ *     value) pair with the given value.
+ */
+goog.labs.structs.Multimap.prototype.containsValue = function(value) {
+  return goog.array.some(this.map_.getValues(),
+      function(values) {
+        return goog.array.some(/** @type {Array} */ (values), function(v) {
+          return goog.labs.object.is(v, value);
+        });
+      });
+};
+
+
+/**
+ * @return {!Array.<string>} An array of unique keys.
+ */
+goog.labs.structs.Multimap.prototype.getKeys = function() {
+  return this.map_.getKeys();
+};
+
+
+/**
+ * @return {!Array.<*>} An array of values. There may be duplicates.
+ */
+goog.labs.structs.Multimap.prototype.getValues = function() {
+  return goog.array.flatten(this.map_.getValues());
+};
+
+
+/**
+ * @return {!Array.<!Array>} An array of entries. Each entry is of the
+ *     form [key, value].
+ */
+goog.labs.structs.Multimap.prototype.getEntries = function() {
+  var keys = this.getKeys();
+  var entries = [];
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var values = this.get(key);
+    for (var j = 0; j < values.length; j++) {
+      entries.push([key, values[j]]);
+    }
+  }
+  return entries;
+};