<!DOCTYPE html>
|
<html>
|
<head>
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
<title>The source code</title>
|
<link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
|
<script type="text/javascript" src="../resources/prettify/prettify.js"></script>
|
<style type="text/css">
|
.highlight { display: block; background-color: #ddd; }
|
</style>
|
<script type="text/javascript">
|
function highlight() {
|
document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
|
}
|
</script>
|
</head>
|
<body onload="prettyPrint(); highlight();">
|
<pre class="prettyprint lang-js"><span id='Ext-util-AbstractMixedCollection'>/**
|
</span> * @class Ext.util.AbstractMixedCollection
|
* @private
|
*/
|
Ext.define('Ext.util.AbstractMixedCollection', {
|
requires: ['Ext.util.Filter'],
|
|
mixins: {
|
observable: 'Ext.util.Observable'
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-property-isMixedCollection'> /**
|
</span> * @property {Boolean} isMixedCollection
|
* `true` in this class to identify an object as an instantiated MixedCollection, or subclass thereof.
|
*/
|
isMixedCollection: true,
|
|
<span id='Ext-util-AbstractMixedCollection-property-generation'> /**
|
</span> * @private Mutation counter which is incremented upon add and remove.
|
*/
|
generation: 0,
|
|
<span id='Ext-util-AbstractMixedCollection-property-indexGeneration'> /**
|
</span> * @private Mutation counter for the index map which is synchronized with the collection's mutation counter
|
* when the index map is interrogated and found to be out of sync and needed a rebuild.
|
*/
|
indexGeneration: 0,
|
|
<span id='Ext-util-AbstractMixedCollection-method-constructor'> constructor: function(allowFunctions, keyFn) {
|
</span> var me = this;
|
|
// Modern constructor signature using a config object
|
if (arguments.length === 1 && Ext.isObject(allowFunctions)) {
|
me.initialConfig = allowFunctions;
|
Ext.apply(me, allowFunctions);
|
}
|
// Old constructor signature
|
else {
|
me.allowFunctions = allowFunctions === true;
|
if (keyFn) {
|
me.getKey = keyFn;
|
}
|
me.initialConfig = {
|
allowFunctions: me.allowFunctions,
|
getKey: me.getKey
|
};
|
}
|
|
me.items = [];
|
me.map = {};
|
me.keys = [];
|
me.indexMap = {};
|
me.length = 0;
|
|
<span id='Ext-util-AbstractMixedCollection-event-clear'> /**
|
</span> * @event clear
|
* Fires when the collection is cleared.
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-util-AbstractMixedCollection-event-add'> /**
|
</span> * @event add
|
* Fires when an item is added to the collection.
|
* @param {Number} index The index at which the item was added.
|
* @param {Object} o The item added.
|
* @param {String} key The key associated with the added item.
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-util-AbstractMixedCollection-event-replace'> /**
|
</span> * @event replace
|
* Fires when an item is replaced in the collection.
|
* @param {String} key he key associated with the new added.
|
* @param {Object} old The item being replaced.
|
* @param {Object} new The new item.
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-util-AbstractMixedCollection-event-remove'> /**
|
</span> * @event remove
|
* Fires when an item is removed from the collection.
|
* @param {Object} o The item being removed.
|
* @param {String} key (optional) The key associated with the removed item.
|
* @since 1.1.0
|
*/
|
|
me.mixins.observable.constructor.call(me);
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-cfg-allowFunctions'> /**
|
</span> * @cfg {Boolean} allowFunctions Specify <code>true</code> if the {@link #addAll}
|
* function should add function references to the collection. Defaults to
|
* <code>false</code>.
|
* @since 3.4.0
|
*/
|
allowFunctions : false,
|
|
<span id='Ext-util-AbstractMixedCollection-method-add'> /**
|
</span> * Adds an item to the collection. Fires the {@link #event-add} event when complete.
|
*
|
* @param {String/Object} key The key to associate with the item, or the new item.
|
*
|
* If a {@link #getKey} implementation was specified for this MixedCollection,
|
* or if the key of the stored items is in a property called `id`,
|
* the MixedCollection will be able to *derive* the key for the new item.
|
* In this case just pass the new item in this parameter.
|
*
|
* @param {Object} [obj] The item to add.
|
*
|
* @return {Object} The item added.
|
* @since 1.1.0
|
*/
|
add : function(key, obj) {
|
var len = this.length,
|
out;
|
|
if (arguments.length === 1) {
|
out = this.insert(len, key);
|
} else {
|
out = this.insert(len, key, obj);
|
}
|
return out;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-getKey'> /**
|
</span> * A function which will be called, passing a newly added object
|
* when the object is added without a separate id. The function
|
* should yield the key by which that object will be indexed.
|
*
|
* If no key is yielded, then the object will be added, but it
|
* cannot be accessed or removed quickly. Finding it in this
|
* collection for interrogation or removal will require a linear
|
* scan of this collection's items.
|
*
|
* The default implementation simply returns `item.id` but you can
|
* provide your own implementation to return a different value as
|
* in the following examples:
|
*
|
* // normal way
|
* var mc = new Ext.util.MixedCollection();
|
* mc.add(someEl.dom.id, someEl);
|
* mc.add(otherEl.dom.id, otherEl);
|
* //and so on
|
*
|
* // using getKey
|
* var mc = new Ext.util.MixedCollection({
|
* getKey: function(el){
|
* return el.dom.id;
|
* }
|
* });
|
* mc.add(someEl);
|
* mc.add(otherEl);
|
*
|
* @param {Object} item The item for which to find the key.
|
* @return {Object} The key for the passed item.
|
* @since 1.1.0
|
* @template
|
*/
|
getKey : function(o) {
|
return o.id;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-replace'> /**
|
</span> * Replaces an item in the collection. Fires the {@link #event-replace} event when complete.
|
* @param {String} key The key associated with the item to replace, or the replacement item.
|
*
|
* If you supplied a {@link #getKey} implementation for this MixedCollection, or if the key
|
* of your stored items is in a property called *`id`*, then the MixedCollection
|
* will be able to <i>derive</i> the key of the replacement item. If you want to replace an item
|
* with one having the same key value, then just pass the replacement item in this parameter.
|
*
|
* @param o {Object} o (optional) If the first parameter passed was a key, the item to associate
|
* with that key.
|
* @return {Object} The new item.
|
* @since 1.1.0
|
*/
|
replace : function(key, o) {
|
var me = this,
|
old,
|
index;
|
|
if (arguments.length == 1) {
|
o = arguments[0];
|
key = me.getKey(o);
|
}
|
old = me.map[key];
|
if (typeof key == 'undefined' || key === null || typeof old == 'undefined') {
|
return me.add(key, o);
|
}
|
me.generation++;
|
index = me.indexOfKey(key);
|
me.items[index] = o;
|
me.map[key] = o;
|
if (me.hasListeners.replace) {
|
me.fireEvent('replace', key, old, o);
|
}
|
return o;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-updateKey'> /**
|
</span> * Change the key for an existing item in the collection. If the old key
|
* does not exist this is a no-op.
|
* @param {Object} oldKey The old key
|
* @param {Object} newKey The new key
|
*/
|
updateKey: function(oldKey, newKey) {
|
var me = this,
|
map = me.map,
|
indexMap = me.indexMap,
|
index = me.indexOfKey(oldKey),
|
item;
|
|
if (index > -1) {
|
item = map[oldKey];
|
delete map[oldKey];
|
delete indexMap[oldKey];
|
map[newKey] = item;
|
indexMap[newKey] = index;
|
me.keys[index] = newKey;
|
me.generation++;
|
|
}
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-addAll'> /**
|
</span> * Adds all elements of an Array or an Object to the collection.
|
* @param {Object/Array} objs An Object containing properties which will be added
|
* to the collection, or an Array of values, each of which are added to the collection.
|
* Functions references will be added to the collection if `{@link #allowFunctions}`
|
* has been set to `true`.
|
* @since 1.1.0
|
*/
|
addAll : function(objs) {
|
var me = this,
|
key;
|
|
if (arguments.length > 1 || Ext.isArray(objs)) {
|
me.insert(me.length, arguments.length > 1 ? arguments : objs);
|
} else {
|
for (key in objs) {
|
if (objs.hasOwnProperty(key)) {
|
if (me.allowFunctions || typeof objs[key] != 'function') {
|
me.add(key, objs[key]);
|
}
|
}
|
}
|
}
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-each'> /**
|
</span> * Executes the specified function once for every item in the collection.
|
* The function should return a boolean value.
|
* Returning false from the function will stop the iteration.
|
*
|
* @param {Function} fn The function to execute for each item.
|
* @param {Mixed} fn.item The collection item.
|
* @param {Number} fn.index The index of item.
|
* @param {Number} fn.len Total length of collection.
|
* @param {Object} scope (optional) The scope (<code>this</code> reference)
|
* in which the function is executed. Defaults to the current item in the iteration.
|
*
|
* @since 1.1.0
|
*/
|
each : function(fn, scope){
|
var items = Ext.Array.push([], this.items), // each safe for removal
|
i = 0,
|
len = items.length,
|
item;
|
|
for (; i < len; i++) {
|
item = items[i];
|
if (fn.call(scope || item, item, i, len) === false) {
|
break;
|
}
|
}
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-eachKey'> /**
|
</span> * Executes the specified function once for every key in the collection, passing each
|
* key, and its associated item as the first two parameters.
|
* @param {Function} fn The function to execute for each item.
|
* @param {String} fn.key The key of collection item.
|
* @param {Mixed} fn.item The collection item.
|
* @param {Number} fn.index The index of item.
|
* @param {Number} fn.len Total length of collection.
|
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the
|
* function is executed. Defaults to the browser window.
|
*
|
* @since 1.1.0
|
*/
|
eachKey : function(fn, scope){
|
var keys = this.keys,
|
items = this.items,
|
i = 0,
|
len = keys.length;
|
|
for (; i < len; i++) {
|
fn.call(scope || window, keys[i], items[i], i, len);
|
}
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-findBy'> /**
|
</span> * Returns the first item in the collection which elicits a true return value from the
|
* passed selection function.
|
* @param {Function} fn The selection function to execute for each item.
|
* @param {Mixed} fn.item The collection item.
|
* @param {String} fn.key The key of collection item.
|
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the
|
* function is executed. Defaults to the browser window.
|
* @return {Object} The first item in the collection which returned true from the selection
|
* function, or null if none was found.
|
*/
|
findBy : function(fn, scope) {
|
var keys = this.keys,
|
items = this.items,
|
i = 0,
|
len = items.length;
|
|
for (; i < len; i++) {
|
if (fn.call(scope || window, items[i], keys[i])) {
|
return items[i];
|
}
|
}
|
return null;
|
},
|
|
//<deprecated since="0.99">
|
<span id='Ext-util-AbstractMixedCollection-method-find'> /**
|
</span> * Returns the first item in the collection which elicits a true return value from the passed selection function.
|
* @deprecated 4.0 Use {@link #findBy} instead.
|
* @since 1.1.0
|
*/
|
find : function() {
|
if (Ext.isDefined(Ext.global.console)) {
|
Ext.global.console.warn('Ext.util.MixedCollection: find has been deprecated. Use findBy instead.');
|
}
|
return this.findBy.apply(this, arguments);
|
},
|
//</deprecated>
|
|
<span id='Ext-util-AbstractMixedCollection-method-insert'> /**
|
</span> * Inserts an item at the specified index in the collection. Fires the {@link #event-add} event when complete.
|
* @param {Number} index The index to insert the item at.
|
* @param {String/Object/String[]/Object[]} key The key to associate with the new item, or the item itself.
|
* May also be an array of either to insert multiple items at once.
|
* @param {Object/Object[]} o (optional) If the second parameter was a key, the new item.
|
* May also be an array to insert multiple items at once.
|
* @return {Object} The item inserted or an array of items inserted.
|
* @since 1.1.0
|
*/
|
insert : function(index, key, obj) {
|
var out;
|
if (Ext.isIterable(key)) {
|
out = this.doInsert(index, key, obj);
|
} else {
|
if (arguments.length > 2) {
|
out = this.doInsert(index, [key], [obj]);
|
} else {
|
out = this.doInsert(index, [key]);
|
}
|
out = out[0];
|
}
|
return out;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-doInsert'> // Private multi insert implementation.
|
</span> doInsert : function(index, keys, objects) {
|
var me = this,
|
itemKey,
|
removeIndex,
|
i, len = keys.length,
|
deDupedLen = len,
|
fireAdd = me.hasListeners.add,
|
syncIndices,
|
newKeys = {},
|
passedDuplicates,
|
oldKeys, oldObjects;
|
|
// External key(s) passed. We cannot reliably find an object's index using the key extraction fn.
|
// Set a flag for use by contains, indexOf and remove
|
if (objects != null) {
|
me.useLinearSearch = true;
|
}
|
// No external keys: calculate keys array if not passed
|
else {
|
objects = keys;
|
keys = new Array(len);
|
for (i = 0; i < len; i++) {
|
keys[i] = this.getKey(objects[i]);
|
}
|
}
|
|
// First, remove duplicates of the keys. If a removal point is less than insertion index, decr insertion index
|
me.suspendEvents();
|
for (i = 0; i < len; i++) {
|
itemKey = keys[i];
|
|
// Must use indexOf - map might be out of sync
|
removeIndex = me.indexOfKey(itemKey);
|
if (removeIndex !== -1) {
|
if (removeIndex < index) {
|
index--;
|
}
|
me.removeAt(removeIndex);
|
}
|
|
if (itemKey != null) {
|
// If a previous new item used this key, we will have to rebuild the input arrays from the newKeys map.
|
if (newKeys[itemKey] != null) {
|
passedDuplicates = true;
|
deDupedLen--;
|
}
|
newKeys[itemKey] = i;
|
}
|
}
|
me.resumeEvents();
|
|
// Duplicate keys were detected - rebuild the objects and keys arrays from the last values associated with each unique key
|
if (passedDuplicates) {
|
oldKeys = keys;
|
oldObjects = objects;
|
keys = new Array(deDupedLen);
|
objects = new Array(deDupedLen);
|
i = 0;
|
|
// Loop through unique key hash, properties of which point to last encountered index for that key.
|
// Rebuild deduped objects and keys arrays.
|
for (itemKey in newKeys) {
|
keys[i] = oldKeys[newKeys[itemKey]];
|
objects[i] = oldObjects[newKeys[itemKey]];
|
i++;
|
}
|
len = deDupedLen;
|
}
|
|
// If we are appending and the indices are in sync, its cheap to kep them that way
|
syncIndices = index === me.length && me.indexGeneration === me.generation;
|
|
// Insert the new items and new keys in at the insertion point
|
Ext.Array.insert(me.items, index, objects);
|
Ext.Array.insert(me.keys, index, keys);
|
me.length += len;
|
me.generation++;
|
if (syncIndices) {
|
me.indexGeneration = me.generation;
|
}
|
for (i = 0; i < len; i++, index++) {
|
itemKey = keys[i];
|
if (itemKey != null) {
|
me.map[itemKey] = objects[i];
|
|
// If the index is still in sync, keep it that way
|
if (syncIndices) {
|
me.indexMap[itemKey] = index;
|
}
|
}
|
if (fireAdd) {
|
me.fireEvent('add', index, objects[i], itemKey);
|
}
|
}
|
return objects;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-remove'> /**
|
</span> * Remove an item from the collection.
|
* @param {Object} o The item to remove.
|
* @return {Object} The item removed or false if no item was removed.
|
* @since 1.1.0
|
*/
|
remove : function(o) {
|
var me = this,
|
removeKey,
|
index;
|
|
// If
|
// We have not been forced into using linear lookup by a usage of the 2 arg form of add
|
// and
|
// The key extraction function yields a key
|
// Then use indexOfKey. This will use the indexMap - rebuilding it if necessary.
|
if (!me.useLinearSearch && (removeKey = me.getKey(o))) {
|
index = me.indexOfKey(removeKey);
|
}
|
|
// Otherwise we have to do it the slow way with a linear search.
|
else {
|
index = Ext.Array.indexOf(me.items, o);
|
}
|
|
return (index === -1) ? false : me.removeAt(index);
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-removeAll'> /**
|
</span> * Remove all items in the collection. Can also be used
|
* to remove only the items in the passed array.
|
* @param {Array} [items] An array of items to be removed.
|
* @return {Ext.util.MixedCollection} this object
|
*/
|
removeAll : function(items) {
|
var me = this,
|
i;
|
|
if (items || me.hasListeners.remove) {
|
// Only perform expensive item-by-item removal if there's a listener or specific items
|
if (items) {
|
for (i = items.length - 1; i >= 0; --i) {
|
me.remove(items[i]);
|
}
|
} else {
|
while (me.length) {
|
me.removeAt(0);
|
}
|
}
|
} else {
|
me.length = me.items.length = me.keys.length = 0;
|
me.map = {};
|
me.indexMap = {};
|
me.generation++;
|
me.indexGeneration = me.generation;
|
}
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-removeAt'> /**
|
</span> * Remove an item from a specified index in the collection. Fires the {@link #event-remove} event when complete.
|
* @param {Number} index The index within the collection of the item to remove.
|
* @return {Object} The item removed or false if no item was removed.
|
* @since 1.1.0
|
*/
|
removeAt : function(index) {
|
var me = this,
|
o,
|
key;
|
|
if (index < me.length && index >= 0) {
|
me.length--;
|
o = me.items[index];
|
Ext.Array.erase(me.items, index, 1);
|
key = me.keys[index];
|
if (typeof key != 'undefined') {
|
delete me.map[key];
|
}
|
Ext.Array.erase(me.keys, index, 1);
|
if (me.hasListeners.remove) {
|
me.fireEvent('remove', o, key);
|
}
|
me.generation++;
|
return o;
|
}
|
return false;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-removeRange'> /**
|
</span> * Remove a range of items starting at a specified index in the collection.
|
* Does not fire the remove event.
|
* @param {Number} index The index within the collection of the item to remove.
|
* @param {Number} [removeCount=1] The nuber of items to remove beginning at the specified index.
|
* @return {Object} The last item removed or false if no item was removed.
|
*/
|
removeRange : function(index, removeCount) {
|
var me = this,
|
o,
|
key,
|
i,
|
limit,
|
syncIndices,
|
trimming;
|
|
if (index < me.length && index >= 0) {
|
if (!removeCount) {
|
removeCount = 1;
|
}
|
limit = Math.min(index + removeCount, me.length);
|
removeCount = limit - index;
|
|
// If we are removing from end and the indices are in sync, its cheap to kep them that way
|
trimming = limit === me.length;
|
syncIndices = trimming && me.indexGeneration === me.generation;
|
|
// Loop through the to remove indices deleting from the key hashes
|
for (i = index; i < limit; i++) {
|
key = me.keys[i];
|
if (key != null) {
|
delete me.map[key];
|
if (syncIndices) {
|
delete me.indexMap[key];
|
}
|
}
|
}
|
// Last item encountered
|
o = me.items[i - 1];
|
|
me.length -= removeCount;
|
me.generation++;
|
if (syncIndices) {
|
me.indexGeneration = me.generation;
|
}
|
|
// Chop items and keys arrays.
|
// If trimming the trailing end, we can just truncate the array.
|
// We can use splice directly. The IE8 bug which Ext.Array works around only affects *insertion*
|
// http://social.msdn.microsoft.com/Forums/en-US/iewebdevelopment/thread/6e946d03-e09f-4b22-a4dd-cd5e276bf05a/
|
if (trimming) {
|
me.items.length = me.keys.length = me.length;
|
} else {
|
me.items.splice(index, removeCount);
|
me.keys.splice(index, removeCount);
|
}
|
|
// Return last object removed
|
return o;
|
}
|
return false;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-removeAtKey'> /**
|
</span> * Removes an item associated with the passed key fom the collection.
|
* @param {String} key The key of the item to remove. If `null` is passed,
|
* all objects which yielded no key from the configured {@link #getKey} function are removed.
|
* @return {Object} Only returned if removing at a specified key. The item removed or false if no item was removed.
|
*/
|
removeAtKey : function(key) {
|
var me = this,
|
keys = me.keys,
|
i;
|
|
// Remove objects which yielded no key from our configured getKey function
|
if (key == null) {
|
for (i = keys.length - 1; i >=0; i--) {
|
if (keys[i] == null) {
|
me.removeAt(i);
|
}
|
}
|
}
|
// Remove object at the passed key
|
else {
|
return me.removeAt(me.indexOfKey(key));
|
}
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-getCount'> /**
|
</span> * Returns the number of items in the collection.
|
* @return {Number} the number of items in the collection.
|
* @since 1.1.0
|
*/
|
getCount : function() {
|
return this.length;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-indexOf'> /**
|
</span> * Returns index within the collection of the passed Object.
|
* @param {Object} o The item to find the index of.
|
* @return {Number} index of the item. Returns -1 if not found.
|
* @since 1.1.0
|
*/
|
indexOf : function(o) {
|
var me = this,
|
key;
|
|
if (o != null) {
|
// If
|
// We have not been forced into using linear lookup by a usage of the 2 arg form of add
|
// and
|
// The key extraction function yields a key
|
// Then use indexOfKey. This will use the indexMap - rebuilding it if necessary.
|
if (!me.useLinearSearch && (key = me.getKey(o))) {
|
return this.indexOfKey(key);
|
}
|
|
// Fallback: Use linear search
|
return Ext.Array.indexOf(me.items, o);
|
}
|
|
// No object passed
|
return -1;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-indexOfKey'> /**
|
</span> * Returns index within the collection of the passed key.
|
* @param {String} key The key to find the index of.
|
* @return {Number} index of the key.
|
* @since 1.1.0
|
*/
|
indexOfKey : function(key) {
|
if (!this.map.hasOwnProperty(key)) {
|
return -1;
|
}
|
if (this.indexGeneration !== this.generation) {
|
this.rebuildIndexMap();
|
}
|
return this.indexMap[key];
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-rebuildIndexMap'> rebuildIndexMap: function() {
|
</span> var me = this,
|
indexMap = me.indexMap = {},
|
keys = me.keys,
|
len = keys.length,
|
i;
|
|
for (i = 0; i < len; i++) {
|
indexMap[keys[i]] = i;
|
}
|
me.indexGeneration = me.generation;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-get'> /**
|
</span> * Returns the item associated with the passed key OR index.
|
* Key has priority over index. This is the equivalent
|
* of calling {@link #getByKey} first, then if nothing matched calling {@link #getAt}.
|
* @param {String/Number} key The key or index of the item.
|
* @return {Object} If the item is found, returns the item. If the item was not found, returns <code>undefined</code>.
|
* If an item was found, but is a Class, returns <code>null</code>.
|
* @since 1.1.0
|
*/
|
get : function(key) {
|
var me = this,
|
mk = me.map[key],
|
item = mk !== undefined ? mk : (typeof key == 'number') ? me.items[key] : undefined;
|
return typeof item != 'function' || me.allowFunctions ? item : null; // for prototype!
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-getAt'> /**
|
</span> * Returns the item at the specified index.
|
* @param {Number} index The index of the item.
|
* @return {Object} The item at the specified index.
|
*/
|
getAt : function(index) {
|
return this.items[index];
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-getByKey'> /**
|
</span> * Returns the item associated with the passed key.
|
* @param {String/Number} key The key of the item.
|
* @return {Object} The item associated with the passed key.
|
*/
|
getByKey : function(key) {
|
return this.map[key];
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-contains'> /**
|
</span> * Returns true if the collection contains the passed Object as an item.
|
* @param {Object} o The Object to look for in the collection.
|
* @return {Boolean} True if the collection contains the Object as an item.
|
* @since 1.1.0
|
*/
|
contains : function(o) {
|
var me = this,
|
key;
|
|
if (o != null) {
|
// If
|
// We have not been forced into using linear lookup by a usage of the 2 arg form of add
|
// and
|
// The key extraction function yields a key
|
// Then use the map to determine object presence.
|
if (!me.useLinearSearch && (key = me.getKey(o))) {
|
return this.map[key] != null;
|
}
|
|
// Fallback: Use linear search
|
return Ext.Array.indexOf(this.items, o) !== -1;
|
}
|
|
return false;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-containsKey'> /**
|
</span> * Returns true if the collection contains the passed Object as a key.
|
* @param {String} key The key to look for in the collection.
|
* @return {Boolean} True if the collection contains the Object as a key.
|
* @since 1.1.0
|
*/
|
containsKey : function(key) {
|
return this.map.hasOwnProperty(key);
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-clear'> /**
|
</span> * Removes all items from the collection. Fires the {@link #event-clear} event when complete.
|
* @since 1.1.0
|
*/
|
clear : function() {
|
var me = this;
|
|
// Only clear if it has ever had any content
|
if (me.generation) {
|
me.length = 0;
|
me.items = [];
|
me.keys = [];
|
me.map = {};
|
me.indexMap = {};
|
|
me.generation++;
|
me.indexGeneration = me.generation;
|
}
|
if (me.hasListeners.clear) {
|
me.fireEvent('clear');
|
}
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-first'> /**
|
</span> * Returns the first item in the collection.
|
* @return {Object} the first item in the collection..
|
* @since 1.1.0
|
*/
|
first : function() {
|
return this.items[0];
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-last'> /**
|
</span> * Returns the last item in the collection.
|
* @return {Object} the last item in the collection..
|
* @since 1.1.0
|
*/
|
last : function() {
|
return this.items[this.length - 1];
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-sum'> /**
|
</span> * Collects all of the values of the given property and returns their sum
|
* @param {String} property The property to sum by
|
* @param {String} [root] 'root' property to extract the first argument from. This is used mainly when
|
* summing fields in records, where the fields are all stored inside the 'data' object
|
* @param {Number} [start=0] The record index to start at
|
* @param {Number} [end=-1] The record index to end at
|
* @return {Number} The total
|
*/
|
sum: function(property, root, start, end) {
|
var values = this.extractValues(property, root),
|
length = values.length,
|
sum = 0,
|
i;
|
|
start = start || 0;
|
end = (end || end === 0) ? end : length - 1;
|
|
for (i = start; i <= end; i++) {
|
sum += values[i];
|
}
|
|
return sum;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-collect'> /**
|
</span> * Collects unique values of a particular property in this MixedCollection
|
* @param {String} property The property to collect on
|
* @param {String} root (optional) 'root' property to extract the first argument from. This is used mainly when
|
* summing fields in records, where the fields are all stored inside the 'data' object
|
* @param {Boolean} allowBlank (optional) Pass true to allow null, undefined or empty string values
|
* @return {Array} The unique values
|
*/
|
collect: function(property, root, allowNull) {
|
var values = this.extractValues(property, root),
|
length = values.length,
|
hits = {},
|
unique = [],
|
value, strValue, i;
|
|
for (i = 0; i < length; i++) {
|
value = values[i];
|
strValue = String(value);
|
|
if ((allowNull || !Ext.isEmpty(value)) && !hits[strValue]) {
|
hits[strValue] = true;
|
unique.push(value);
|
}
|
}
|
|
return unique;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-extractValues'> /**
|
</span> * @private
|
* Extracts all of the given property values from the items in the MC. Mainly used as a supporting method for
|
* functions like sum and collect.
|
* @param {String} property The property to extract
|
* @param {String} root (optional) 'root' property to extract the first argument from. This is used mainly when
|
* extracting field data from Model instances, where the fields are stored inside the 'data' object
|
* @return {Array} The extracted values
|
*/
|
extractValues: function(property, root) {
|
var values = this.items;
|
|
if (root) {
|
values = Ext.Array.pluck(values, root);
|
}
|
|
return Ext.Array.pluck(values, property);
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-hasRange'> /**
|
</span> * @private
|
* For API parity with Store's PageMap class. Buffered rendering checks if the Store has the range
|
* required to render. The Store delegates this question to its backing data object which may be an instance
|
* of its private PageMap class, or a MixedCollection.
|
*/
|
hasRange: function(start, end) {
|
return (end < this.length);
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-getRange'> /**
|
</span> * Returns a range of items in this collection
|
* @param {Number} startIndex (optional) The starting index. Defaults to 0.
|
* @param {Number} endIndex (optional) The ending index. Defaults to the last item.
|
* @return {Array} An array of items
|
* @since 1.1.0
|
*/
|
getRange : function(start, end){
|
var me = this,
|
items = me.items,
|
range = [],
|
len = items.length,
|
tmp, reverse;
|
|
if (len < 1) {
|
return range;
|
}
|
|
if (start > end) {
|
reverse = true;
|
tmp = start;
|
start = end;
|
end = tmp;
|
}
|
|
if (start < 0) {
|
start = 0;
|
}
|
|
if (end == null || end >= len) {
|
end = len - 1;
|
}
|
|
range = items.slice(start, end + 1);
|
if (reverse && range.length) {
|
range.reverse();
|
}
|
return range;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-filter'> /**
|
</span> * <p>Filters the objects in this collection by a set of {@link Ext.util.Filter Filter}s, or by a single
|
* property/value pair with optional parameters for substring matching and case sensitivity. See
|
* {@link Ext.util.Filter Filter} for an example of using Filter objects (preferred). Alternatively,
|
* MixedCollection can be easily filtered by property like this:</p>
|
*
|
* //create a simple store with a few people defined
|
* var people = new Ext.util.MixedCollection();
|
* people.addAll([
|
* {id: 1, age: 25, name: 'Ed'},
|
* {id: 2, age: 24, name: 'Tommy'},
|
* {id: 3, age: 24, name: 'Arne'},
|
* {id: 4, age: 26, name: 'Aaron'}
|
* ]);
|
*
|
* //a new MixedCollection containing only the items where age == 24
|
* var middleAged = people.filter('age', 24);
|
*
|
* @param {Ext.util.Filter[]/String} property A property on your objects, or an array of {@link Ext.util.Filter Filter} objects
|
* @param {String/RegExp} value Either string that the property values
|
* should start with or a RegExp to test against the property
|
* @param {Boolean} [anyMatch=false] True to match any part of the string, not just the beginning
|
* @param {Boolean} [caseSensitive=false] True for case sensitive comparison.
|
* @return {Ext.util.MixedCollection} The new filtered collection
|
* @since 1.1.0
|
*/
|
filter : function(property, value, anyMatch, caseSensitive) {
|
var filters = [];
|
|
//support for the simple case of filtering by property/value
|
if (Ext.isString(property)) {
|
filters.push(new Ext.util.Filter({
|
property : property,
|
value : value,
|
anyMatch : anyMatch,
|
caseSensitive: caseSensitive
|
}));
|
} else if (Ext.isArray(property) || property instanceof Ext.util.Filter) {
|
filters = filters.concat(property);
|
}
|
|
// At this point we have an array of zero or more Ext.util.Filter objects to filter with,
|
// so here we construct a function that combines these filters by ANDing them together
|
// and filter by that.
|
return this.filterBy(Ext.util.Filter.createFilterFn(filters));
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-filterBy'> /**
|
</span> * Filter by a function. Returns a <i>new</i> collection that has been filtered.
|
* The passed function will be called with each object in the collection.
|
* If the function returns true, the value is included otherwise it is filtered.
|
* @param {Function} fn The function to be called.
|
* @param {Mixed} fn.item The collection item.
|
* @param {String} fn.key The key of collection item.
|
* @param {Object} scope (optional) The scope (<code>this</code> reference) in
|
* which the function is executed. Defaults to this MixedCollection.
|
* @return {Ext.util.MixedCollection} The new filtered collection
|
* @since 1.1.0
|
*/
|
filterBy : function(fn, scope) {
|
var me = this,
|
newMC = new me.self(me.initialConfig),
|
keys = me.keys,
|
items = me.items,
|
length = items.length,
|
i;
|
|
newMC.getKey = me.getKey;
|
|
for (i = 0; i < length; i++) {
|
if (fn.call(scope || me, items[i], keys[i])) {
|
newMC.add(keys[i], items[i]);
|
}
|
}
|
|
return newMC;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-findIndex'> /**
|
</span> * Finds the index of the first matching object in this collection by a specific property/value.
|
* @param {String} property The name of a property on your objects.
|
* @param {String/RegExp} value A string that the property values
|
* should start with or a RegExp to test against the property.
|
* @param {Number} [start=0] The index to start searching at.
|
* @param {Boolean} [anyMatch=false] True to match any part of the string, not just the beginning.
|
* @param {Boolean} [caseSensitive=false] True for case sensitive comparison.
|
* @return {Number} The matched index or -1
|
* @since 2.3.0
|
*/
|
findIndex : function(property, value, start, anyMatch, caseSensitive){
|
if(Ext.isEmpty(value, false)){
|
return -1;
|
}
|
value = this.createValueMatcher(value, anyMatch, caseSensitive);
|
return this.findIndexBy(function(o){
|
return o && value.test(o[property]);
|
}, null, start);
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-findIndexBy'> /**
|
</span> * Find the index of the first matching object in this collection by a function.
|
* If the function returns <i>true</i> it is considered a match.
|
* @param {Function} fn The function to be called.
|
* @param {Mixed} fn.item The collection item.
|
* @param {String} fn.key The key of collection item.
|
* @param {Object} [scope] The scope (<code>this</code> reference) in which the function is executed. Defaults to this MixedCollection.
|
* @param {Number} [start=0] The index to start searching at.
|
* @return {Number} The matched index or -1
|
* @since 2.3.0
|
*/
|
findIndexBy : function(fn, scope, start){
|
var me = this,
|
keys = me.keys,
|
items = me.items,
|
i = start || 0,
|
len = items.length;
|
|
for (; i < len; i++) {
|
if (fn.call(scope || me, items[i], keys[i])) {
|
return i;
|
}
|
}
|
return -1;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-createValueMatcher'> /**
|
</span> * Returns a regular expression based on the given value and matching options. This is used internally for finding and filtering,
|
* and by Ext.data.Store#filter
|
* @private
|
* @param {String} value The value to create the regex for. This is escaped using Ext.escapeRe
|
* @param {Boolean} anyMatch True to allow any match - no regex start/end line anchors will be added. Defaults to false
|
* @param {Boolean} caseSensitive True to make the regex case sensitive (adds 'i' switch to regex). Defaults to false.
|
* @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false. Ignored if anyMatch is true.
|
* @since 3.4.0
|
*/
|
createValueMatcher : function(value, anyMatch, caseSensitive, exactMatch) {
|
if (!value.exec) { // not a regex
|
var er = Ext.String.escapeRegex;
|
value = String(value);
|
|
if (anyMatch === true) {
|
value = er(value);
|
} else {
|
value = '^' + er(value);
|
if (exactMatch === true) {
|
value += '$';
|
}
|
}
|
value = new RegExp(value, caseSensitive ? '' : 'i');
|
}
|
return value;
|
},
|
|
<span id='Ext-util-AbstractMixedCollection-method-clone'> /**
|
</span> * Creates a shallow copy of this collection
|
* @return {Ext.util.MixedCollection}
|
* @since 1.1.0
|
*/
|
clone : function() {
|
var me = this,
|
copy = new this.self(me.initialConfig);
|
|
copy.add(me.keys, me.items);
|
return copy;
|
}
|
});
|
</pre>
|
</body>
|
</html>
|
