summaryrefslogtreecommitdiff
path: root/srv/src/http/static/viz/2/goog/structs
diff options
context:
space:
mode:
authorBrian Picciano <mediocregopher@gmail.com>2022-09-13 12:56:08 +0200
committerBrian Picciano <mediocregopher@gmail.com>2022-09-13 12:56:08 +0200
commit4f01edb9230f58ff84b0dd892c931ec8ac9aad55 (patch)
tree9c1598a3f98203913ac2548883c02a81deb33dc7 /srv/src/http/static/viz/2/goog/structs
parent5485984e05aebde22819adebfbd5ad51475a6c21 (diff)
move src out of srv, clean up default.nix and Makefile
Diffstat (limited to 'srv/src/http/static/viz/2/goog/structs')
-rw-r--r--srv/src/http/static/viz/2/goog/structs/map.js458
-rw-r--r--srv/src/http/static/viz/2/goog/structs/structs.js354
2 files changed, 0 insertions, 812 deletions
diff --git a/srv/src/http/static/viz/2/goog/structs/map.js b/srv/src/http/static/viz/2/goog/structs/map.js
deleted file mode 100644
index 1cb4bcc..0000000
--- a/srv/src/http/static/viz/2/goog/structs/map.js
+++ /dev/null
@@ -1,458 +0,0 @@
-// Copyright 2006 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 Datastructure: Hash Map.
- *
- * @author arv@google.com (Erik Arvidsson)
- *
- * This file contains an implementation of a Map structure. It implements a lot
- * of the methods used in goog.structs so those functions work on hashes. This
- * is best suited for complex key types. For simple keys such as numbers and
- * strings consider using the lighter-weight utilities in goog.object.
- */
-
-
-goog.provide('goog.structs.Map');
-
-goog.require('goog.iter.Iterator');
-goog.require('goog.iter.StopIteration');
-goog.require('goog.object');
-
-
-
-/**
- * Class for Hash Map datastructure.
- * @param {*=} opt_map Map or Object to initialize the map with.
- * @param {...*} var_args If 2 or more arguments are present then they
- * will be used as key-value pairs.
- * @constructor
- * @template K, V
- * @deprecated This type is misleading: use ES6 Map instead.
- */
-goog.structs.Map = function(opt_map, var_args) {
-
- /**
- * Underlying JS object used to implement the map.
- * @private {!Object}
- */
- this.map_ = {};
-
- /**
- * An array of keys. This is necessary for two reasons:
- * 1. Iterating the keys using for (var key in this.map_) allocates an
- * object for every key in IE which is really bad for IE6 GC perf.
- * 2. Without a side data structure, we would need to escape all the keys
- * as that would be the only way we could tell during iteration if the
- * key was an internal key or a property of the object.
- *
- * This array can contain deleted keys so it's necessary to check the map
- * as well to see if the key is still in the map (this doesn't require a
- * memory allocation in IE).
- * @private {!Array<string>}
- */
- this.keys_ = [];
-
- /**
- * The number of key value pairs in the map.
- * @private {number}
- */
- this.count_ = 0;
-
- /**
- * Version used to detect changes while iterating.
- * @private {number}
- */
- this.version_ = 0;
-
- var argLength = arguments.length;
-
- if (argLength > 1) {
- if (argLength % 2) {
- throw Error('Uneven number of arguments');
- }
- for (var i = 0; i < argLength; i += 2) {
- this.set(arguments[i], arguments[i + 1]);
- }
- } else if (opt_map) {
- this.addAll(/** @type {Object} */ (opt_map));
- }
-};
-
-
-/**
- * @return {number} The number of key-value pairs in the map.
- */
-goog.structs.Map.prototype.getCount = function() {
- return this.count_;
-};
-
-
-/**
- * Returns the values of the map.
- * @return {!Array<V>} The values in the map.
- */
-goog.structs.Map.prototype.getValues = function() {
- this.cleanupKeysArray_();
-
- var rv = [];
- for (var i = 0; i < this.keys_.length; i++) {
- var key = this.keys_[i];
- rv.push(this.map_[key]);
- }
- return rv;
-};
-
-
-/**
- * Returns the keys of the map.
- * @return {!Array<string>} Array of string values.
- */
-goog.structs.Map.prototype.getKeys = function() {
- this.cleanupKeysArray_();
- return /** @type {!Array<string>} */ (this.keys_.concat());
-};
-
-
-/**
- * Whether the map contains the given key.
- * @param {*} key The key to check for.
- * @return {boolean} Whether the map contains the key.
- */
-goog.structs.Map.prototype.containsKey = function(key) {
- return goog.structs.Map.hasKey_(this.map_, key);
-};
-
-
-/**
- * Whether the map contains the given value. This is O(n).
- * @param {V} val The value to check for.
- * @return {boolean} Whether the map contains the value.
- */
-goog.structs.Map.prototype.containsValue = function(val) {
- for (var i = 0; i < this.keys_.length; i++) {
- var key = this.keys_[i];
- if (goog.structs.Map.hasKey_(this.map_, key) && this.map_[key] == val) {
- return true;
- }
- }
- return false;
-};
-
-
-/**
- * Whether this map is equal to the argument map.
- * @param {goog.structs.Map} otherMap The map against which to test equality.
- * @param {function(V, V): boolean=} opt_equalityFn Optional equality function
- * to test equality of values. If not specified, this will test whether
- * the values contained in each map are identical objects.
- * @return {boolean} Whether the maps are equal.
- */
-goog.structs.Map.prototype.equals = function(otherMap, opt_equalityFn) {
- if (this === otherMap) {
- return true;
- }
-
- if (this.count_ != otherMap.getCount()) {
- return false;
- }
-
- var equalityFn = opt_equalityFn || goog.structs.Map.defaultEquals;
-
- this.cleanupKeysArray_();
- for (var key, i = 0; key = this.keys_[i]; i++) {
- if (!equalityFn(this.get(key), otherMap.get(key))) {
- return false;
- }
- }
-
- return true;
-};
-
-
-/**
- * Default equality test for values.
- * @param {*} a The first value.
- * @param {*} b The second value.
- * @return {boolean} Whether a and b reference the same object.
- */
-goog.structs.Map.defaultEquals = function(a, b) {
- return a === b;
-};
-
-
-/**
- * @return {boolean} Whether the map is empty.
- */
-goog.structs.Map.prototype.isEmpty = function() {
- return this.count_ == 0;
-};
-
-
-/**
- * Removes all key-value pairs from the map.
- */
-goog.structs.Map.prototype.clear = function() {
- this.map_ = {};
- this.keys_.length = 0;
- this.count_ = 0;
- this.version_ = 0;
-};
-
-
-/**
- * Removes a key-value pair based on the key. This is O(logN) amortized due to
- * updating the keys array whenever the count becomes half the size of the keys
- * in the keys array.
- * @param {*} key The key to remove.
- * @return {boolean} Whether object was removed.
- */
-goog.structs.Map.prototype.remove = function(key) {
- if (goog.structs.Map.hasKey_(this.map_, key)) {
- delete this.map_[key];
- this.count_--;
- this.version_++;
-
- // clean up the keys array if the threshold is hit
- if (this.keys_.length > 2 * this.count_) {
- this.cleanupKeysArray_();
- }
-
- return true;
- }
- return false;
-};
-
-
-/**
- * Cleans up the temp keys array by removing entries that are no longer in the
- * map.
- * @private
- */
-goog.structs.Map.prototype.cleanupKeysArray_ = function() {
- if (this.count_ != this.keys_.length) {
- // First remove keys that are no longer in the map.
- var srcIndex = 0;
- var destIndex = 0;
- while (srcIndex < this.keys_.length) {
- var key = this.keys_[srcIndex];
- if (goog.structs.Map.hasKey_(this.map_, key)) {
- this.keys_[destIndex++] = key;
- }
- srcIndex++;
- }
- this.keys_.length = destIndex;
- }
-
- if (this.count_ != this.keys_.length) {
- // If the count still isn't correct, that means we have duplicates. This can
- // happen when the same key is added and removed multiple times. Now we have
- // to allocate one extra Object to remove the duplicates. This could have
- // been done in the first pass, but in the common case, we can avoid
- // allocating an extra object by only doing this when necessary.
- var seen = {};
- var srcIndex = 0;
- var destIndex = 0;
- while (srcIndex < this.keys_.length) {
- var key = this.keys_[srcIndex];
- if (!(goog.structs.Map.hasKey_(seen, key))) {
- this.keys_[destIndex++] = key;
- seen[key] = 1;
- }
- srcIndex++;
- }
- this.keys_.length = destIndex;
- }
-};
-
-
-/**
- * Returns the value for the given key. If the key is not found and the default
- * value is not given this will return {@code undefined}.
- * @param {*} key The key to get the value for.
- * @param {DEFAULT=} opt_val The value to return if no item is found for the
- * given key, defaults to undefined.
- * @return {V|DEFAULT} The value for the given key.
- * @template DEFAULT
- */
-goog.structs.Map.prototype.get = function(key, opt_val) {
- if (goog.structs.Map.hasKey_(this.map_, key)) {
- return this.map_[key];
- }
- return opt_val;
-};
-
-
-/**
- * Adds a key-value pair to the map.
- * @param {*} key The key.
- * @param {V} value The value to add.
- * @return {*} Some subclasses return a value.
- */
-goog.structs.Map.prototype.set = function(key, value) {
- if (!(goog.structs.Map.hasKey_(this.map_, key))) {
- this.count_++;
- // TODO(johnlenz): This class lies, it claims to return an array of string
- // keys, but instead returns the original object used.
- this.keys_.push(/** @type {?} */ (key));
- // Only change the version if we add a new key.
- this.version_++;
- }
- this.map_[key] = value;
-};
-
-
-/**
- * Adds multiple key-value pairs from another goog.structs.Map or Object.
- * @param {Object} map Object containing the data to add.
- */
-goog.structs.Map.prototype.addAll = function(map) {
- var keys, values;
- if (map instanceof goog.structs.Map) {
- keys = map.getKeys();
- values = map.getValues();
- } else {
- keys = goog.object.getKeys(map);
- values = goog.object.getValues(map);
- }
- // we could use goog.array.forEach here but I don't want to introduce that
- // dependency just for this.
- for (var i = 0; i < keys.length; i++) {
- this.set(keys[i], values[i]);
- }
-};
-
-
-/**
- * Calls the given function on each entry in the map.
- * @param {function(this:T, V, K, goog.structs.Map<K,V>)} f
- * @param {T=} opt_obj The value of "this" inside f.
- * @template T
- */
-goog.structs.Map.prototype.forEach = function(f, opt_obj) {
- var keys = this.getKeys();
- for (var i = 0; i < keys.length; i++) {
- var key = keys[i];
- var value = this.get(key);
- f.call(opt_obj, value, key, this);
- }
-};
-
-
-/**
- * Clones a map and returns a new map.
- * @return {!goog.structs.Map} A new map with the same key-value pairs.
- */
-goog.structs.Map.prototype.clone = function() {
- return new goog.structs.Map(this);
-};
-
-
-/**
- * Returns a new map in which all the keys and values are interchanged
- * (keys become values and values become keys). If multiple keys map to the
- * same value, the chosen transposed value is implementation-dependent.
- *
- * It acts very similarly to {goog.object.transpose(Object)}.
- *
- * @return {!goog.structs.Map} The transposed map.
- */
-goog.structs.Map.prototype.transpose = function() {
- var transposed = new goog.structs.Map();
- for (var i = 0; i < this.keys_.length; i++) {
- var key = this.keys_[i];
- var value = this.map_[key];
- transposed.set(value, key);
- }
-
- return transposed;
-};
-
-
-/**
- * @return {!Object} Object representation of the map.
- */
-goog.structs.Map.prototype.toObject = function() {
- this.cleanupKeysArray_();
- var obj = {};
- for (var i = 0; i < this.keys_.length; i++) {
- var key = this.keys_[i];
- obj[key] = this.map_[key];
- }
- return obj;
-};
-
-
-/**
- * Returns an iterator that iterates over the keys in the map. Removal of keys
- * while iterating might have undesired side effects.
- * @return {!goog.iter.Iterator} An iterator over the keys in the map.
- */
-goog.structs.Map.prototype.getKeyIterator = function() {
- return this.__iterator__(true);
-};
-
-
-/**
- * Returns an iterator that iterates over the values in the map. Removal of
- * keys while iterating might have undesired side effects.
- * @return {!goog.iter.Iterator} An iterator over the values in the map.
- */
-goog.structs.Map.prototype.getValueIterator = function() {
- return this.__iterator__(false);
-};
-
-
-/**
- * Returns an iterator that iterates over the values or the keys in the map.
- * This throws an exception if the map was mutated since the iterator was
- * created.
- * @param {boolean=} opt_keys True to iterate over the keys. False to iterate
- * over the values. The default value is false.
- * @return {!goog.iter.Iterator} An iterator over the values or keys in the map.
- */
-goog.structs.Map.prototype.__iterator__ = function(opt_keys) {
- // Clean up keys to minimize the risk of iterating over dead keys.
- this.cleanupKeysArray_();
-
- var i = 0;
- var version = this.version_;
- var selfObj = this;
-
- var newIter = new goog.iter.Iterator;
- newIter.next = function() {
- if (version != selfObj.version_) {
- throw Error('The map has changed since the iterator was created');
- }
- if (i >= selfObj.keys_.length) {
- throw goog.iter.StopIteration;
- }
- var key = selfObj.keys_[i++];
- return opt_keys ? key : selfObj.map_[key];
- };
- return newIter;
-};
-
-
-/**
- * Safe way to test for hasOwnProperty. It even allows testing for
- * 'hasOwnProperty'.
- * @param {Object} obj The object to test for presence of the given key.
- * @param {*} key The key to check for.
- * @return {boolean} Whether the object has the key.
- * @private
- */
-goog.structs.Map.hasKey_ = function(obj, key) {
- return Object.prototype.hasOwnProperty.call(obj, key);
-};
diff --git a/srv/src/http/static/viz/2/goog/structs/structs.js b/srv/src/http/static/viz/2/goog/structs/structs.js
deleted file mode 100644
index 684ddfe..0000000
--- a/srv/src/http/static/viz/2/goog/structs/structs.js
+++ /dev/null
@@ -1,354 +0,0 @@
-// Copyright 2006 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 Generics method for collection-like classes and objects.
- *
- * @author arv@google.com (Erik Arvidsson)
- *
- * This file contains functions to work with collections. It supports using
- * Map, Set, Array and Object and other classes that implement collection-like
- * methods.
- */
-
-
-goog.provide('goog.structs');
-
-goog.require('goog.array');
-goog.require('goog.object');
-
-
-// We treat an object as a dictionary if it has getKeys or it is an object that
-// isn't arrayLike.
-
-
-/**
- * Returns the number of values in the collection-like object.
- * @param {Object} col The collection-like object.
- * @return {number} The number of values in the collection-like object.
- */
-goog.structs.getCount = function(col) {
- if (col.getCount && typeof col.getCount == 'function') {
- return col.getCount();
- }
- if (goog.isArrayLike(col) || goog.isString(col)) {
- return col.length;
- }
- return goog.object.getCount(col);
-};
-
-
-/**
- * Returns the values of the collection-like object.
- * @param {Object} col The collection-like object.
- * @return {!Array<?>} The values in the collection-like object.
- */
-goog.structs.getValues = function(col) {
- if (col.getValues && typeof col.getValues == 'function') {
- return col.getValues();
- }
- if (goog.isString(col)) {
- return col.split('');
- }
- if (goog.isArrayLike(col)) {
- var rv = [];
- var l = col.length;
- for (var i = 0; i < l; i++) {
- rv.push(col[i]);
- }
- return rv;
- }
- return goog.object.getValues(col);
-};
-
-
-/**
- * Returns the keys of the collection. Some collections have no notion of
- * keys/indexes and this function will return undefined in those cases.
- * @param {Object} col The collection-like object.
- * @return {!Array|undefined} The keys in the collection.
- */
-goog.structs.getKeys = function(col) {
- if (col.getKeys && typeof col.getKeys == 'function') {
- return col.getKeys();
- }
- // if we have getValues but no getKeys we know this is a key-less collection
- if (col.getValues && typeof col.getValues == 'function') {
- return undefined;
- }
- if (goog.isArrayLike(col) || goog.isString(col)) {
- var rv = [];
- var l = col.length;
- for (var i = 0; i < l; i++) {
- rv.push(i);
- }
- return rv;
- }
-
- return goog.object.getKeys(col);
-};
-
-
-/**
- * Whether the collection contains the given value. This is O(n) and uses
- * equals (==) to test the existence.
- * @param {Object} col The collection-like object.
- * @param {*} val The value to check for.
- * @return {boolean} True if the map contains the value.
- */
-goog.structs.contains = function(col, val) {
- if (col.contains && typeof col.contains == 'function') {
- return col.contains(val);
- }
- if (col.containsValue && typeof col.containsValue == 'function') {
- return col.containsValue(val);
- }
- if (goog.isArrayLike(col) || goog.isString(col)) {
- return goog.array.contains(/** @type {!Array<?>} */ (col), val);
- }
- return goog.object.containsValue(col, val);
-};
-
-
-/**
- * Whether the collection is empty.
- * @param {Object} col The collection-like object.
- * @return {boolean} True if empty.
- */
-goog.structs.isEmpty = function(col) {
- if (col.isEmpty && typeof col.isEmpty == 'function') {
- return col.isEmpty();
- }
-
- // We do not use goog.string.isEmptyOrWhitespace because here we treat the
- // string as
- // collection and as such even whitespace matters
-
- if (goog.isArrayLike(col) || goog.isString(col)) {
- return goog.array.isEmpty(/** @type {!Array<?>} */ (col));
- }
- return goog.object.isEmpty(col);
-};
-
-
-/**
- * Removes all the elements from the collection.
- * @param {Object} col The collection-like object.
- */
-goog.structs.clear = function(col) {
- // NOTE(arv): This should not contain strings because strings are immutable
- if (col.clear && typeof col.clear == 'function') {
- col.clear();
- } else if (goog.isArrayLike(col)) {
- goog.array.clear(/** @type {IArrayLike<?>} */ (col));
- } else {
- goog.object.clear(col);
- }
-};
-
-
-/**
- * Calls a function for each value in a collection. The function takes
- * three arguments; the value, the key and the collection.
- *
- * @param {S} col The collection-like object.
- * @param {function(this:T,?,?,S):?} f The function to call for every value.
- * This function takes
- * 3 arguments (the value, the key or undefined if the collection has no
- * notion of keys, and the collection) and the return value is irrelevant.
- * @param {T=} opt_obj The object to be used as the value of 'this'
- * within {@code f}.
- * @template T,S
- * @deprecated Use a more specific method, e.g. goog.array.forEach,
- * goog.object.forEach, or for-of.
- */
-goog.structs.forEach = function(col, f, opt_obj) {
- if (col.forEach && typeof col.forEach == 'function') {
- col.forEach(f, opt_obj);
- } else if (goog.isArrayLike(col) || goog.isString(col)) {
- goog.array.forEach(/** @type {!Array<?>} */ (col), f, opt_obj);
- } else {
- var keys = goog.structs.getKeys(col);
- var values = goog.structs.getValues(col);
- var l = values.length;
- for (var i = 0; i < l; i++) {
- f.call(/** @type {?} */ (opt_obj), values[i], keys && keys[i], col);
- }
- }
-};
-
-
-/**
- * Calls a function for every value in the collection. When a call returns true,
- * adds the value to a new collection (Array is returned by default).
- *
- * @param {S} col The collection-like object.
- * @param {function(this:T,?,?,S):boolean} f The function to call for every
- * value. This function takes
- * 3 arguments (the value, the key or undefined if the collection has no
- * notion of keys, and the collection) and should return a Boolean. If the
- * return value is true the value is added to the result collection. If it
- * is false the value is not included.
- * @param {T=} opt_obj The object to be used as the value of 'this'
- * within {@code f}.
- * @return {!Object|!Array<?>} A new collection where the passed values are
- * present. If col is a key-less collection an array is returned. If col
- * has keys and values a plain old JS object is returned.
- * @template T,S
- */
-goog.structs.filter = function(col, f, opt_obj) {
- if (typeof col.filter == 'function') {
- return col.filter(f, opt_obj);
- }
- if (goog.isArrayLike(col) || goog.isString(col)) {
- return goog.array.filter(/** @type {!Array<?>} */ (col), f, opt_obj);
- }
-
- var rv;
- var keys = goog.structs.getKeys(col);
- var values = goog.structs.getValues(col);
- var l = values.length;
- if (keys) {
- rv = {};
- for (var i = 0; i < l; i++) {
- if (f.call(/** @type {?} */ (opt_obj), values[i], keys[i], col)) {
- rv[keys[i]] = values[i];
- }
- }
- } else {
- // We should not use goog.array.filter here since we want to make sure that
- // the index is undefined as well as make sure that col is passed to the
- // function.
- rv = [];
- for (var i = 0; i < l; i++) {
- if (f.call(opt_obj, values[i], undefined, col)) {
- rv.push(values[i]);
- }
- }
- }
- return rv;
-};
-
-
-/**
- * Calls a function for every value in the collection and adds the result into a
- * new collection (defaults to creating a new Array).
- *
- * @param {S} col The collection-like object.
- * @param {function(this:T,?,?,S):V} f The function to call for every value.
- * This function takes 3 arguments (the value, the key or undefined if the
- * collection has no notion of keys, and the collection) and should return
- * something. The result will be used as the value in the new collection.
- * @param {T=} opt_obj The object to be used as the value of 'this'
- * within {@code f}.
- * @return {!Object<V>|!Array<V>} A new collection with the new values. If
- * col is a key-less collection an array is returned. If col has keys and
- * values a plain old JS object is returned.
- * @template T,S,V
- */
-goog.structs.map = function(col, f, opt_obj) {
- if (typeof col.map == 'function') {
- return col.map(f, opt_obj);
- }
- if (goog.isArrayLike(col) || goog.isString(col)) {
- return goog.array.map(/** @type {!Array<?>} */ (col), f, opt_obj);
- }
-
- var rv;
- var keys = goog.structs.getKeys(col);
- var values = goog.structs.getValues(col);
- var l = values.length;
- if (keys) {
- rv = {};
- for (var i = 0; i < l; i++) {
- rv[keys[i]] = f.call(/** @type {?} */ (opt_obj), values[i], keys[i], col);
- }
- } else {
- // We should not use goog.array.map here since we want to make sure that
- // the index is undefined as well as make sure that col is passed to the
- // function.
- rv = [];
- for (var i = 0; i < l; i++) {
- rv[i] = f.call(/** @type {?} */ (opt_obj), values[i], undefined, col);
- }
- }
- return rv;
-};
-
-
-/**
- * Calls f for each value in a collection. If any call returns true this returns
- * true (without checking the rest). If all returns false this returns false.
- *
- * @param {S} col The collection-like object.
- * @param {function(this:T,?,?,S):boolean} f The function to call for every
- * value. This function takes 3 arguments (the value, the key or undefined
- * if the collection has no notion of keys, and the collection) and should
- * return a boolean.
- * @param {T=} opt_obj The object to be used as the value of 'this'
- * within {@code f}.
- * @return {boolean} True if any value passes the test.
- * @template T,S
- */
-goog.structs.some = function(col, f, opt_obj) {
- if (typeof col.some == 'function') {
- return col.some(f, opt_obj);
- }
- if (goog.isArrayLike(col) || goog.isString(col)) {
- return goog.array.some(/** @type {!Array<?>} */ (col), f, opt_obj);
- }
- var keys = goog.structs.getKeys(col);
- var values = goog.structs.getValues(col);
- var l = values.length;
- for (var i = 0; i < l; i++) {
- if (f.call(/** @type {?} */ (opt_obj), values[i], keys && keys[i], col)) {
- return true;
- }
- }
- return false;
-};
-
-
-/**
- * Calls f for each value in a collection. If all calls return true this return
- * true this returns true. If any returns false this returns false at this point
- * and does not continue to check the remaining values.
- *
- * @param {S} col The collection-like object.
- * @param {function(this:T,?,?,S):boolean} f The function to call for every
- * value. This function takes 3 arguments (the value, the key or
- * undefined if the collection has no notion of keys, and the collection)
- * and should return a boolean.
- * @param {T=} opt_obj The object to be used as the value of 'this'
- * within {@code f}.
- * @return {boolean} True if all key-value pairs pass the test.
- * @template T,S
- */
-goog.structs.every = function(col, f, opt_obj) {
- if (typeof col.every == 'function') {
- return col.every(f, opt_obj);
- }
- if (goog.isArrayLike(col) || goog.isString(col)) {
- return goog.array.every(/** @type {!Array<?>} */ (col), f, opt_obj);
- }
- var keys = goog.structs.getKeys(col);
- var values = goog.structs.getValues(col);
- var l = values.length;
- for (var i = 0; i < l; i++) {
- if (!f.call(/** @type {?} */ (opt_obj), values[i], keys && keys[i], col)) {
- return false;
- }
- }
- return true;
-};