/**
* @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;