text: /*
  This file is part of Ext JS 4.2
  
  Copyright (c) 2011-2013 Sencha Inc
  
  Contact:  http://www.sencha.com/contact
  
  GNU General Public License Usage
  This file may be used under the terms of the GNU General Public License version 3.0 as
  published by the Free Software Foundation and appearing in the file LICENSE included in the
  packaging of this file.
  
  Please review the following information to ensure the GNU General Public License version 3.0
  requirements will be met: http://www.gnu.org/copyleft/gpl.html.
  
  If you are unsure which license is appropriate for your use, please contact the sales department
  at http://www.sencha.com/contact.
  
  Build date: 2013-05-16 14:36:50 (f9be68accb407158ba2b1be2c226a6ce1f649314)
  */
  /**
   * @class Ext.util.AbstractMixedCollection
   * @private
   */
  Ext.define('Ext.util.AbstractMixedCollection', {
      requires: ['Ext.util.Filter'],
  
      mixins: {
          observable: 'Ext.util.Observable'
      },
  
      /**
       * @property {Boolean} isMixedCollection
       * `true` in this class to identify an object as an instantiated MixedCollection, or subclass thereof.
       */
      isMixedCollection: true,
  
      /**
       * @private Mutation counter which is incremented upon add and remove.
       */
      generation: 0,
      
      /**
       * @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,
      
      constructor: function(allowFunctions, keyFn) {
          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;
  
          /**
           * @event clear
           * Fires when the collection is cleared.
           * @since 1.1.0
           */
  
          /**
           * @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
           */
  
          /**
           * @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
           */
         
          /**
           * @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);
      },
  
      /**
       * @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,
  
      /**
       * 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;
      },
  
      /**
       * 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;
      },
  
      /**
       * 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;
      },
      
      /**
       * 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++;
              
          }
      },
  
      /**
       * 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]);
                      }
                  }
              }
          }
      },
  
      /**
       * 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;
              }
          }
      },
  
      /**
       * 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);
          }
      },
  
      /**
       * 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">
      /**
       * 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>
  
      /**
       * 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;
      },
   
      // Private multi insert implementation.
      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;
      },
  
      /**
       * 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);
      },
  
      /**
       * 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;
          }
      },
      
      /**
       * 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;
      },
  
      /**
       * 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;
      },
  
      /**
       * 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));
          }
      },
  
      /**
       * 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;
      },
  
      /**
       * 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;
      },
  
      /**
       * 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];
      },
      
      rebuildIndexMap: function() {
          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;
      },
  
      /**
       * 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!
      },
  
      /**
       * 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];
      },
  
      /**
       * 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];
      },
  
      /**
       * 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;
      },
  
      /**
       * 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);
      },
  
      /**
       * 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');
          }
      },
  
      /**
       * 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];
      },
  
      /**
       * 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];
      },
  
      /**
       * 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;
      },
  
      /**
       * 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;
      },
  
      /**
       * @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);
      },
  
      /**
       * @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);
      },
  
      /**
       * 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;
      },
  
      /**
       * <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));
      },
  
      /**
       * 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;
      },
  
      /**
       * 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);
      },
  
      /**
       * 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;
      },
  
      /**
       * 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;
      },
  
      /**
       * 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;
      }
  });
  