initial commit

js/goog/memoize/memoize.js

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright The Closure Library Authors.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Tool for caching the result of expensive deterministic
+ * functions.
+ *
+ * @see http://en.wikipedia.org/wiki/Memoization
+ */
+
+goog.module('goog.memoize');
+goog.module.declareLegacyNamespace();
+
+const reflect = goog.require('goog.reflect');
+
+/**
+ * Note that when using the WeakMap polyfill users may run into issues
+ * where memoize is unable to store a cache properly (as the polyfill tries to
+ * store the values on the key object as properties.). The workaround is to not
+ * memoize onto a sealed context if the code needs to run in browsers where
+ * WeakMap is not available (IE<=10 as an example).
+ * @type {!WeakMap<!Object, !Object>}
+ */
+const MODULE_LOCAL_CACHE = new WeakMap();
+
+/**
+ * Decorator around functions that caches the inner function's return values.
+ *
+ * To cache parameterless functions, see goog.functions.cacheReturnValue.
+ *
+ * @param {Function} f The function to wrap. Its return value may only depend
+ *     on its arguments and 'this' context. There may be further restrictions
+ *     on the arguments depending on the capabilities of the serializer used.
+ * @param {function(number, !IArrayLike<?>): string=} serializer A function to
+ *     serialize f's arguments. It must have the same signature as
+ *     goog.memoize.simpleSerializer. It defaults to that function.
+ * @return {!Function} The wrapped function.
+ */
+function memoize(f, serializer = simpleSerializer) {
+  const uidF = goog.getUid(f);
+  const keyFn = ([that, ...args]) => serializer(uidF, args);
+  const valueFn = ([that, ...args]) => f.apply(that, args);
+
+  /**
+   * @this {Object} The object whose function is being wrapped.
+   * @param {...*} args
+   * @return {?} the return value of the original function.
+   */
+  const memoizedFn = function(...args) {
+    if (memoize.ENABLE_MEMOIZE) {
+      const cacheKey = this || goog.global;
+      let cache = MODULE_LOCAL_CACHE.get(cacheKey);
+      if (!cache) {
+        cache = {};
+        MODULE_LOCAL_CACHE.set(cacheKey, cache);
+      }
+      return reflect.cache(cache, [this, ...args], valueFn, keyFn);
+    } else {
+      return f.apply(this, args);
+    }
+  };
+  return memoizedFn;
+}
+exports = memoize;
+
+/**
+ * @define {boolean} Flag to disable memoization in unit tests.
+ */
+memoize.ENABLE_MEMOIZE = goog.define('goog.memoize.ENABLE_MEMOIZE', true);
+
+
+/**
+ * Clears the memoization cache on the given object.
+ * @param {?Object} cacheOwner The owner of the cache.
+ */
+const clearCache = function(cacheOwner) {
+  MODULE_LOCAL_CACHE.set(cacheOwner || goog.global, {});
+};
+exports.clearCache = clearCache;
+
+
+/**
+ * Simple and fast argument serializer function for goog.memoize.
+ * Supports string, number, boolean, null and undefined arguments. Doesn't
+ * support \x0B characters in the strings.
+ * @param {number} functionUid Unique identifier of the function whose result
+ *     is cached.
+ * @param {!IArrayLike<?>} args The arguments that the function to memoize is
+ *     called with. Note: it is an array-like object, because it supports
+ *     indexing and has the length property.
+ * @return {string} The list of arguments with type information concatenated
+ *     with the functionUid argument, serialized as \x0B-separated string.
+ */
+const simpleSerializer = function(functionUid, args) {
+  const context = [functionUid];
+  for (let i = args.length - 1; i >= 0; --i) {
+    context.push(typeof args[i], args[i]);
+  }
+  return context.join('\x0B');
+};
+exports.simpleSerializer = simpleSerializer;