docs/source/Store2.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-data-Store-method-constructor'><span id='Ext-data-Store'>/**
  19 </span></span> * @author Ed Spencer
  20  * @class Ext.data.Store
  21  * @extends Ext.data.AbstractStore
  22  *
  23  * &lt;p&gt;The Store class encapsulates a client side cache of {@link Ext.data.Model Model} objects. Stores load
  24  * data via a {@link Ext.data.proxy.Proxy Proxy}, and also provide functions for {@link #sort sorting},
  25  * {@link #filter filtering} and querying the {@link Ext.data.Model model} instances contained within it.&lt;/p&gt;
  26  *
  27  * &lt;p&gt;Creating a Store is easy - we just tell it the Model and the Proxy to use to load and save its data:&lt;/p&gt;
  28  *
  29 &lt;pre&gt;&lt;code&gt;
  30 // Set up a {@link Ext.data.Model model} to use in our Store
  31 Ext.define('User', {
  32     extend: 'Ext.data.Model',
  33     fields: [
  34         {name: 'firstName', type: 'string'},
  35         {name: 'lastName',  type: 'string'},
  36         {name: 'age',       type: 'int'},
  37         {name: 'eyeColor',  type: 'string'}
  38     ]
  39 });
  40
  41 var myStore = new Ext.data.Store({
  42     model: 'User',
  43     proxy: {
  44         type: 'ajax',
  45         url : '/users.json',
  46         reader: {
  47             type: 'json',
  48             root: 'users'
  49         }
  50     },
  51     autoLoad: true
  52 });
  53 &lt;/code&gt;&lt;/pre&gt;
  54
  55  * &lt;p&gt;In the example above we configured an AJAX proxy to load data from the url '/users.json'. We told our Proxy
  56  * to use a {@link Ext.data.reader.Json JsonReader} to parse the response from the server into Model object -
  57  * {@link Ext.data.reader.Json see the docs on JsonReader} for details.&lt;/p&gt;
  58  *
  59  * &lt;p&gt;&lt;u&gt;Inline data&lt;/u&gt;&lt;/p&gt;
  60  *
  61  * &lt;p&gt;Stores can also load data inline. Internally, Store converts each of the objects we pass in as {@link #data}
  62  * into Model instances:&lt;/p&gt;
  63  *
  64 &lt;pre&gt;&lt;code&gt;
  65 new Ext.data.Store({
  66     model: 'User',
  67     data : [
  68         {firstName: 'Ed',    lastName: 'Spencer'},
  69         {firstName: 'Tommy', lastName: 'Maintz'},
  70         {firstName: 'Aaron', lastName: 'Conran'},
  71         {firstName: 'Jamie', lastName: 'Avins'}
  72     ]
  73 });
  74 &lt;/code&gt;&lt;/pre&gt;
  75  *
  76  * &lt;p&gt;Loading inline data using the method above is great if the data is in the correct format already (e.g. it doesn't need
  77  * to be processed by a {@link Ext.data.reader.Reader reader}). If your inline data requires processing to decode the data structure,
  78  * use a {@link Ext.data.proxy.Memory MemoryProxy} instead (see the {@link Ext.data.proxy.Memory MemoryProxy} docs for an example).&lt;/p&gt;
  79  *
  80  * &lt;p&gt;Additional data can also be loaded locally using {@link #add}.&lt;/p&gt;
  81  *
  82  * &lt;p&gt;&lt;u&gt;Loading Nested Data&lt;/u&gt;&lt;/p&gt;
  83  *
  84  * &lt;p&gt;Applications often need to load sets of associated data - for example a CRM system might load a User and her Orders.
  85  * Instead of issuing an AJAX request for the User and a series of additional AJAX requests for each Order, we can load a nested dataset
  86  * and allow the Reader to automatically populate the associated models. Below is a brief example, see the {@link Ext.data.reader.Reader} intro
  87  * docs for a full explanation:&lt;/p&gt;
  88  *
  89 &lt;pre&gt;&lt;code&gt;
  90 var store = new Ext.data.Store({
  91     autoLoad: true,
  92     model: &quot;User&quot;,
  93     proxy: {
  94         type: 'ajax',
  95         url : 'users.json',
  96         reader: {
  97             type: 'json',
  98             root: 'users'
  99         }
 100     }
 101 });
 102 &lt;/code&gt;&lt;/pre&gt;
 103  *
 104  * &lt;p&gt;Which would consume a response like this:&lt;/p&gt;
 105  *
 106 &lt;pre&gt;&lt;code&gt;
 107 {
 108     &quot;users&quot;: [
 109         {
 110             &quot;id&quot;: 1,
 111             &quot;name&quot;: &quot;Ed&quot;,
 112             &quot;orders&quot;: [
 113                 {
 114                     &quot;id&quot;: 10,
 115                     &quot;total&quot;: 10.76,
 116                     &quot;status&quot;: &quot;invoiced&quot;
 117                 },
 118                 {
 119                     &quot;id&quot;: 11,
 120                     &quot;total&quot;: 13.45,
 121                     &quot;status&quot;: &quot;shipped&quot;
 122                 }
 123             ]
 124         }
 125     ]
 126 }
 127 &lt;/code&gt;&lt;/pre&gt;
 128  *
 129  * &lt;p&gt;See the {@link Ext.data.reader.Reader} intro docs for a full explanation.&lt;/p&gt;
 130  *
 131  * &lt;p&gt;&lt;u&gt;Filtering and Sorting&lt;/u&gt;&lt;/p&gt;
 132  *
 133  * &lt;p&gt;Stores can be sorted and filtered - in both cases either remotely or locally. The {@link #sorters} and {@link #filters} are
 134  * held inside {@link Ext.util.MixedCollection MixedCollection} instances to make them easy to manage. Usually it is sufficient to
 135  * either just specify sorters and filters in the Store configuration or call {@link #sort} or {@link #filter}:
 136  *
 137 &lt;pre&gt;&lt;code&gt;
 138 var store = new Ext.data.Store({
 139     model: 'User',
 140     sorters: [
 141         {
 142             property : 'age',
 143             direction: 'DESC'
 144         },
 145         {
 146             property : 'firstName',
 147             direction: 'ASC'
 148         }
 149     ],
 150
 151     filters: [
 152         {
 153             property: 'firstName',
 154             value   : /Ed/
 155         }
 156     ]
 157 });
 158 &lt;/code&gt;&lt;/pre&gt;
 159  *
 160  * &lt;p&gt;The new Store will keep the configured sorters and filters in the MixedCollection instances mentioned above. By default, sorting
 161  * and filtering are both performed locally by the Store - see {@link #remoteSort} and {@link #remoteFilter} to allow the server to
 162  * perform these operations instead.&lt;/p&gt;
 163  *
 164  * &lt;p&gt;Filtering and sorting after the Store has been instantiated is also easy. Calling {@link #filter} adds another filter to the Store
 165  * and automatically filters the dataset (calling {@link #filter} with no arguments simply re-applies all existing filters). Note that by
 166  * default {@link #sortOnFilter} is set to true, which means that your sorters are automatically reapplied if using local sorting.&lt;/p&gt;
 167  *
 168 &lt;pre&gt;&lt;code&gt;
 169 store.filter('eyeColor', 'Brown');
 170 &lt;/code&gt;&lt;/pre&gt;
 171  *
 172  * &lt;p&gt;Change the sorting at any time by calling {@link #sort}:&lt;/p&gt;
 173  *
 174 &lt;pre&gt;&lt;code&gt;
 175 store.sort('height', 'ASC');
 176 &lt;/code&gt;&lt;/pre&gt;
 177  *
 178  * &lt;p&gt;Note that all existing sorters will be removed in favor of the new sorter data (if {@link #sort} is called with no arguments,
 179  * the existing sorters are just reapplied instead of being removed). To keep existing sorters and add new ones, just add them
 180  * to the MixedCollection:&lt;/p&gt;
 181  *
 182 &lt;pre&gt;&lt;code&gt;
 183 store.sorters.add(new Ext.util.Sorter({
 184     property : 'shoeSize',
 185     direction: 'ASC'
 186 }));
 187
 188 store.sort();
 189 &lt;/code&gt;&lt;/pre&gt;
 190  *
 191  * &lt;p&gt;&lt;u&gt;Registering with StoreManager&lt;/u&gt;&lt;/p&gt;
 192  *
 193  * &lt;p&gt;Any Store that is instantiated with a {@link #storeId} will automatically be registed with the {@link Ext.data.StoreManager StoreManager}.
 194  * This makes it easy to reuse the same store in multiple views:&lt;/p&gt;
 195  *
 196  &lt;pre&gt;&lt;code&gt;
 197 //this store can be used several times
 198 new Ext.data.Store({
 199     model: 'User',
 200     storeId: 'usersStore'
 201 });
 202
 203 new Ext.List({
 204     store: 'usersStore',
 205
 206     //other config goes here
 207 });
 208
 209 new Ext.view.View({
 210     store: 'usersStore',
 211
 212     //other config goes here
 213 });
 214 &lt;/code&gt;&lt;/pre&gt;
 215  *
 216  * &lt;p&gt;&lt;u&gt;Further Reading&lt;/u&gt;&lt;/p&gt;
 217  *
 218  * &lt;p&gt;Stores are backed up by an ecosystem of classes that enables their operation. To gain a full understanding of these
 219  * pieces and how they fit together, see:&lt;/p&gt;
 220  *
 221  * &lt;ul style=&quot;list-style-type: disc; padding-left: 25px&quot;&gt;
 222  * &lt;li&gt;{@link Ext.data.proxy.Proxy Proxy} - overview of what Proxies are and how they are used&lt;/li&gt;
 223  * &lt;li&gt;{@link Ext.data.Model Model} - the core class in the data package&lt;/li&gt;
 224  * &lt;li&gt;{@link Ext.data.reader.Reader Reader} - used by any subclass of {@link Ext.data.proxy.Server ServerProxy} to read a response&lt;/li&gt;
 225  * &lt;/ul&gt;
 226  *
 227  * @constructor
 228  * @param {Object} config Optional config object
 229  */
 230 Ext.define('Ext.data.Store', {
 231     extend: 'Ext.data.AbstractStore',
 232
 233     alias: 'store.store',
 234
 235     requires: ['Ext.ModelManager', 'Ext.data.Model', 'Ext.util.Grouper'],
 236     uses: ['Ext.data.proxy.Memory'],
 237
 238 <span id='Ext-data-Store-cfg-remoteSort'>    /**
 239 </span>     * @cfg {Boolean} remoteSort
 240      * True to defer any sorting operation to the server. If false, sorting is done locally on the client. Defaults to &lt;tt&gt;false&lt;/tt&gt;.
 241      */
 242     remoteSort: false,
 243
 244 <span id='Ext-data-Store-cfg-remoteFilter'>    /**
 245 </span>     * @cfg {Boolean} remoteFilter
 246      * True to defer any filtering operation to the server. If false, filtering is done locally on the client. Defaults to &lt;tt&gt;false&lt;/tt&gt;.
 247      */
 248     remoteFilter: false,
 249
 250 <span id='Ext-data-Store-cfg-remoteGroup'>    /**
 251 </span>     * @cfg {Boolean} remoteGroup
 252      * True if the grouping should apply on the server side, false if it is local only (defaults to false).  If the
 253      * grouping is local, it can be applied immediately to the data.  If it is remote, then it will simply act as a
 254      * helper, automatically sending the grouping information to the server.
 255      */
 256     remoteGroup : false,
 257
 258 <span id='Ext-data-Store-cfg-proxy'>    /**
 259 </span>     * @cfg {String/Ext.data.proxy.Proxy/Object} proxy The Proxy to use for this Store. This can be either a string, a config
 260      * object or a Proxy instance - see {@link #setProxy} for details.
 261      */
 262
 263 <span id='Ext-data-Store-cfg-data'>    /**
 264 </span>     * @cfg {Array} data Optional array of Model instances or data objects to load locally. See &quot;Inline data&quot; above for details.
 265      */
 266
 267 <span id='Ext-data-Store-cfg-model'>    /**
 268 </span>     * @cfg {String} model The {@link Ext.data.Model} associated with this store
 269      */
 270
 271 <span id='Ext-data-Store-property-groupField'>    /**
 272 </span>     * The (optional) field by which to group data in the store. Internally, grouping is very similar to sorting - the
 273      * groupField and {@link #groupDir} are injected as the first sorter (see {@link #sort}). Stores support a single
 274      * level of grouping, and groups can be fetched via the {@link #getGroups} method.
 275      * @property groupField
 276      * @type String
 277      */
 278     groupField: undefined,
 279
 280 <span id='Ext-data-Store-property-groupDir'>    /**
 281 </span>     * The direction in which sorting should be applied when grouping. Defaults to &quot;ASC&quot; - the other supported value is &quot;DESC&quot;
 282      * @property groupDir
 283      * @type String
 284      */
 285     groupDir: &quot;ASC&quot;,
 286
 287 <span id='Ext-data-Store-cfg-pageSize'>    /**
 288 </span>     * @cfg {Number} pageSize
 289      * The number of records considered to form a 'page'. This is used to power the built-in
 290      * paging using the nextPage and previousPage functions. Defaults to 25.
 291      */
 292     pageSize: 25,
 293
 294 <span id='Ext-data-Store-property-currentPage'>    /**
 295 </span>     * The page that the Store has most recently loaded (see {@link #loadPage})
 296      * @property currentPage
 297      * @type Number
 298      */
 299     currentPage: 1,
 300
 301 <span id='Ext-data-Store-cfg-clearOnPageLoad'>    /**
 302 </span>     * @cfg {Boolean} clearOnPageLoad True to empty the store when loading another page via {@link #loadPage},
 303      * {@link #nextPage} or {@link #previousPage} (defaults to true). Setting to false keeps existing records, allowing
 304      * large data sets to be loaded one page at a time but rendered all together.
 305      */
 306     clearOnPageLoad: true,
 307
 308 <span id='Ext-data-Store-property-loading'>    /**
 309 </span>     * True if the Store is currently loading via its Proxy
 310      * @property loading
 311      * @type Boolean
 312      * @private
 313      */
 314     loading: false,
 315
 316 <span id='Ext-data-Store-cfg-sortOnFilter'>    /**
 317 </span>     * @cfg {Boolean} sortOnFilter For local filtering only, causes {@link #sort} to be called whenever {@link #filter} is called,
 318      * causing the sorters to be reapplied after filtering. Defaults to true
 319      */
 320     sortOnFilter: true,
 321
 322 <span id='Ext-data-Store-cfg-buffered'>    /**
 323 </span>     * @cfg {Boolean} buffered
 324      * Allow the store to buffer and pre-fetch pages of records. This is to be used in conjunction with a view will
 325      * tell the store to pre-fetch records ahead of a time.
 326      */
 327     buffered: false,
 328
 329 <span id='Ext-data-Store-cfg-purgePageCount'>    /**
 330 </span>     * @cfg {Number} purgePageCount
 331      * The number of pages to keep in the cache before purging additional records. A value of 0 indicates to never purge the prefetched data.
 332      * This option is only relevant when the {@link #buffered} option is set to true.
 333      */
 334     purgePageCount: 5,
 335
 336     isStore: true,
 337
 338     //documented above
 339     constructor: function(config) {
 340         config = config || {};
 341
 342         var me = this,
 343             groupers = config.groupers || me.groupers,
 344             groupField = config.groupField || me.groupField,
 345             proxy,
 346             data;
 347
 348         if (config.buffered || me.buffered) {
 349             me.prefetchData = Ext.create('Ext.util.MixedCollection', false, function(record) {
 350                 return record.index;
 351             });
 352             me.pendingRequests = [];
 353             me.pagesRequested = [];
 354
 355             me.sortOnLoad = false;
 356             me.filterOnLoad = false;
 357         }
 358
 359         me.addEvents(
 360 <span id='Ext-data-Store-event-beforeprefetch'>            /**
 361 </span>             * @event beforeprefetch
 362              * Fires before a prefetch occurs. Return false to cancel.
 363              * @param {Ext.data.store} this
 364              * @param {Ext.data.Operation} operation The associated operation
 365              */
 366             'beforeprefetch',
 367 <span id='Ext-data-Store-event-groupchange'>            /**
 368 </span>             * @event groupchange
 369              * Fired whenever the grouping in the grid changes
 370              * @param {Ext.data.Store} store The store
 371              * @param {Array} groupers The array of grouper objects
 372              */
 373             'groupchange',
 374 <span id='Ext-data-Store-event-load'>            /**
 375 </span>             * @event load
 376              * Fires whenever records have been prefetched
 377              * @param {Ext.data.store} this
 378              * @param {Array} records An array of records
 379              * @param {Boolean} successful True if the operation was successful.
 380              * @param {Ext.data.Operation} operation The associated operation
 381              */
 382             'prefetch'
 383         );
 384         data = config.data || me.data;
 385
 386 <span id='Ext-data-Store-property-data'>        /**
 387 </span>         * The MixedCollection that holds this store's local cache of records
 388          * @property data
 389          * @type Ext.util.MixedCollection
 390          */
 391         me.data = Ext.create('Ext.util.MixedCollection', false, function(record) {
 392             return record.internalId;
 393         });
 394
 395         if (data) {
 396             me.inlineData = data;
 397             delete config.data;
 398         }
 399
 400         if (!groupers &amp;&amp; groupField) {
 401             groupers = [{
 402                 property : groupField,
 403                 direction: config.groupDir || me.groupDir
 404             }];
 405         }
 406         delete config.groupers;
 407
 408 <span id='Ext-data-Store-property-groupers'>        /**
 409 </span>         * The collection of {@link Ext.util.Grouper Groupers} currently applied to this Store
 410          * @property groupers
 411          * @type Ext.util.MixedCollection
 412          */
 413         me.groupers = Ext.create('Ext.util.MixedCollection');
 414         me.groupers.addAll(me.decodeGroupers(groupers));
 415
 416         this.callParent([config]);
 417         // don't use *config* anymore from here on... use *me* instead...
 418
 419         if (me.groupers.items.length) {
 420             me.sort(me.groupers.items, 'prepend', false);
 421         }
 422
 423         proxy = me.proxy;
 424         data = me.inlineData;
 425
 426         if (data) {
 427             if (proxy instanceof Ext.data.proxy.Memory) {
 428                 proxy.data = data;
 429                 me.read();
 430             } else {
 431                 me.add.apply(me, data);
 432             }
 433
 434             me.sort();
 435             delete me.inlineData;
 436         } else if (me.autoLoad) {
 437             Ext.defer(me.load, 10, me, [typeof me.autoLoad === 'object' ? me.autoLoad: undefined]);
 438             // Remove the defer call, we may need reinstate this at some point, but currently it's not obvious why it's here.
 439             // this.load(typeof this.autoLoad == 'object' ? this.autoLoad : undefined);
 440         }
 441     },
 442
 443     onBeforeSort: function() {
 444         this.sort(this.groupers.items, 'prepend', false);
 445     },
 446
 447 <span id='Ext-data-Store-method-decodeGroupers'>    /**
 448 </span>     * @private
 449      * Normalizes an array of grouper objects, ensuring that they are all Ext.util.Grouper instances
 450      * @param {Array} groupers The groupers array
 451      * @return {Array} Array of Ext.util.Grouper objects
 452      */
 453     decodeGroupers: function(groupers) {
 454         if (!Ext.isArray(groupers)) {
 455             if (groupers === undefined) {
 456                 groupers = [];
 457             } else {
 458                 groupers = [groupers];
 459             }
 460         }
 461
 462         var length  = groupers.length,
 463             Grouper = Ext.util.Grouper,
 464             config, i;
 465
 466         for (i = 0; i &lt; length; i++) {
 467             config = groupers[i];
 468
 469             if (!(config instanceof Grouper)) {
 470                 if (Ext.isString(config)) {
 471                     config = {
 472                         property: config
 473                     };
 474                 }
 475
 476                 Ext.applyIf(config, {
 477                     root     : 'data',
 478                     direction: &quot;ASC&quot;
 479                 });
 480
 481                 //support for 3.x style sorters where a function can be defined as 'fn'
 482                 if (config.fn) {
 483                     config.sorterFn = config.fn;
 484                 }
 485
 486                 //support a function to be passed as a sorter definition
 487                 if (typeof config == 'function') {
 488                     config = {
 489                         sorterFn: config
 490                     };
 491                 }
 492
 493                 groupers[i] = new Grouper(config);
 494             }
 495         }
 496
 497         return groupers;
 498     },
 499
 500 <span id='Ext-data-Store-method-group'>    /**
 501 </span>     * Group data in the store
 502      * @param {String|Array} groupers Either a string name of one of the fields in this Store's configured {@link Ext.data.Model Model},
 503      * or an Array of grouper configurations.
 504      * @param {String} direction The overall direction to group the data by. Defaults to &quot;ASC&quot;.
 505      */
 506     group: function(groupers, direction) {
 507         var me = this,
 508             grouper,
 509             newGroupers;
 510
 511         if (Ext.isArray(groupers)) {
 512             newGroupers = groupers;
 513         } else if (Ext.isObject(groupers)) {
 514             newGroupers = [groupers];
 515         } else if (Ext.isString(groupers)) {
 516             grouper = me.groupers.get(groupers);
 517
 518             if (!grouper) {
 519                 grouper = {
 520                     property : groupers,
 521                     direction: direction
 522                 };
 523                 newGroupers = [grouper];
 524             } else if (direction === undefined) {
 525                 grouper.toggle();
 526             } else {
 527                 grouper.setDirection(direction);
 528             }
 529         }
 530
 531         if (newGroupers &amp;&amp; newGroupers.length) {
 532             newGroupers = me.decodeGroupers(newGroupers);
 533             me.groupers.clear();
 534             me.groupers.addAll(newGroupers);
 535         }
 536
 537         if (me.remoteGroup) {
 538             me.load({
 539                 scope: me,
 540                 callback: me.fireGroupChange
 541             });
 542         } else {
 543             me.sort();
 544             me.fireEvent('groupchange', me, me.groupers);
 545         }
 546     },
 547
 548 <span id='Ext-data-Store-method-clearGrouping'>    /**
 549 </span>     * Clear any groupers in the store
 550      */
 551     clearGrouping: function(){
 552         var me = this;
 553         // Clear any groupers we pushed on to the sorters
 554         me.groupers.each(function(grouper){
 555             me.sorters.remove(grouper);
 556         });
 557         me.groupers.clear();
 558         if (me.remoteGroup) {
 559             me.load({
 560                 scope: me,
 561                 callback: me.fireGroupChange
 562             });
 563         } else {
 564             me.sort();
 565             me.fireEvent('groupchange', me, me.groupers);
 566         }
 567     },
 568
 569 <span id='Ext-data-Store-method-isGrouped'>    /**
 570 </span>     * Checks if the store is currently grouped
 571      * @return {Boolean} True if the store is grouped.
 572      */
 573     isGrouped: function() {
 574         return this.groupers.getCount() &gt; 0;
 575     },
 576
 577 <span id='Ext-data-Store-method-fireGroupChange'>    /**
 578 </span>     * Fires the groupchange event. Abstracted out so we can use it
 579      * as a callback
 580      * @private
 581      */
 582     fireGroupChange: function(){
 583         this.fireEvent('groupchange', this, this.groupers);
 584     },
 585
 586 <span id='Ext-data-Store-method-getGroups'>    /**
 587 </span>     * Returns an object containing the result of applying grouping to the records in this store. See {@link #groupField},
 588      * {@link #groupDir} and {@link #getGroupString}. Example for a store containing records with a color field:
 589 &lt;pre&gt;&lt;code&gt;
 590 var myStore = new Ext.data.Store({
 591     groupField: 'color',
 592     groupDir  : 'DESC'
 593 });
 594
 595 myStore.getGroups(); //returns:
 596 [
 597     {
 598         name: 'yellow',
 599         children: [
 600             //all records where the color field is 'yellow'
 601         ]
 602     },
 603     {
 604         name: 'red',
 605         children: [
 606             //all records where the color field is 'red'
 607         ]
 608     }
 609 ]
 610 &lt;/code&gt;&lt;/pre&gt;
 611      * @param {String} groupName (Optional) Pass in an optional groupName argument to access a specific group as defined by {@link #getGroupString}
 612      * @return {Array} The grouped data
 613      */
 614     getGroups: function(requestGroupString) {
 615         var records = this.data.items,
 616             length = records.length,
 617             groups = [],
 618             pointers = {},
 619             record,
 620             groupStr,
 621             group,
 622             i;
 623
 624         for (i = 0; i &lt; length; i++) {
 625             record = records[i];
 626             groupStr = this.getGroupString(record);
 627             group = pointers[groupStr];
 628
 629             if (group === undefined) {
 630                 group = {
 631                     name: groupStr,
 632                     children: []
 633                 };
 634
 635                 groups.push(group);
 636                 pointers[groupStr] = group;
 637             }
 638
 639             group.children.push(record);
 640         }
 641
 642         return requestGroupString ? pointers[requestGroupString] : groups;
 643     },
 644
 645 <span id='Ext-data-Store-method-getGroupsForGrouper'>    /**
 646 </span>     * @private
 647      * For a given set of records and a Grouper, returns an array of arrays - each of which is the set of records
 648      * matching a certain group.
 649      */
 650     getGroupsForGrouper: function(records, grouper) {
 651         var length = records.length,
 652             groups = [],
 653             oldValue,
 654             newValue,
 655             record,
 656             group,
 657             i;
 658
 659         for (i = 0; i &lt; length; i++) {
 660             record = records[i];
 661             newValue = grouper.getGroupString(record);
 662
 663             if (newValue !== oldValue) {
 664                 group = {
 665                     name: newValue,
 666                     grouper: grouper,
 667                     records: []
 668                 };
 669                 groups.push(group);
 670             }
 671
 672             group.records.push(record);
 673
 674             oldValue = newValue;
 675         }
 676
 677         return groups;
 678     },
 679
 680 <span id='Ext-data-Store-method-getGroupsForGrouperIndex'>    /**
 681 </span>     * @private
 682      * This is used recursively to gather the records into the configured Groupers. The data MUST have been sorted for
 683      * this to work properly (see {@link #getGroupData} and {@link #getGroupsForGrouper}) Most of the work is done by
 684      * {@link #getGroupsForGrouper} - this function largely just handles the recursion.
 685      * @param {Array} records The set or subset of records to group
 686      * @param {Number} grouperIndex The grouper index to retrieve
 687      * @return {Array} The grouped records
 688      */
 689     getGroupsForGrouperIndex: function(records, grouperIndex) {
 690         var me = this,
 691             groupers = me.groupers,
 692             grouper = groupers.getAt(grouperIndex),
 693             groups = me.getGroupsForGrouper(records, grouper),
 694             length = groups.length,
 695             i;
 696
 697         if (grouperIndex + 1 &lt; groupers.length) {
 698             for (i = 0; i &lt; length; i++) {
 699                 groups[i].children = me.getGroupsForGrouperIndex(groups[i].records, grouperIndex + 1);
 700             }
 701         }
 702
 703         for (i = 0; i &lt; length; i++) {
 704             groups[i].depth = grouperIndex;
 705         }
 706
 707         return groups;
 708     },
 709
 710 <span id='Ext-data-Store-method-getGroupData'>    /**
 711 </span>     * @private
 712      * &lt;p&gt;Returns records grouped by the configured {@link #groupers grouper} configuration. Sample return value (in
 713      * this case grouping by genre and then author in a fictional books dataset):&lt;/p&gt;
 714 &lt;pre&gt;&lt;code&gt;
 715 [
 716     {
 717         name: 'Fantasy',
 718         depth: 0,
 719         records: [
 720             //book1, book2, book3, book4
 721         ],
 722         children: [
 723             {
 724                 name: 'Rowling',
 725                 depth: 1,
 726                 records: [
 727                     //book1, book2
 728                 ]
 729             },
 730             {
 731                 name: 'Tolkein',
 732                 depth: 1,
 733                 records: [
 734                     //book3, book4
 735                 ]
 736             }
 737         ]
 738     }
 739 ]
 740 &lt;/code&gt;&lt;/pre&gt;
 741      * @param {Boolean} sort True to call {@link #sort} before finding groups. Sorting is required to make grouping
 742      * function correctly so this should only be set to false if the Store is known to already be sorted correctly
 743      * (defaults to true)
 744      * @return {Array} The group data
 745      */
 746     getGroupData: function(sort) {
 747         var me = this;
 748         if (sort !== false) {
 749             me.sort();
 750         }
 751
 752         return me.getGroupsForGrouperIndex(me.data.items, 0);
 753     },
 754
 755 <span id='Ext-data-Store-method-getGroupString'>    /**
 756 </span>     * &lt;p&gt;Returns the string to group on for a given model instance. The default implementation of this method returns
 757      * the model's {@link #groupField}, but this can be overridden to group by an arbitrary string. For example, to
 758      * group by the first letter of a model's 'name' field, use the following code:&lt;/p&gt;
 759 &lt;pre&gt;&lt;code&gt;
 760 new Ext.data.Store({
 761     groupDir: 'ASC',
 762     getGroupString: function(instance) {
 763         return instance.get('name')[0];
 764     }
 765 });
 766 &lt;/code&gt;&lt;/pre&gt;
 767      * @param {Ext.data.Model} instance The model instance
 768      * @return {String} The string to compare when forming groups
 769      */
 770     getGroupString: function(instance) {
 771         var group = this.groupers.first();
 772         if (group) {
 773             return instance.get(group.property);
 774         }
 775         return '';
 776     },
 777 <span id='Ext-data-Store-method-insert'>    /**
 778 </span>     * Inserts Model instances into the Store at the given index and fires the {@link #add} event.
 779      * See also &lt;code&gt;{@link #add}&lt;/code&gt;.
 780      * @param {Number} index The start index at which to insert the passed Records.
 781      * @param {Ext.data.Model[]} records An Array of Ext.data.Model objects to add to the cache.
 782      */
 783     insert: function(index, records) {
 784         var me = this,
 785             sync = false,
 786             i,
 787             record,
 788             len;
 789
 790         records = [].concat(records);
 791         for (i = 0, len = records.length; i &lt; len; i++) {
 792             record = me.createModel(records[i]);
 793             record.set(me.modelDefaults);
 794             // reassign the model in the array in case it wasn't created yet
 795             records[i] = record;
 796
 797             me.data.insert(index + i, record);
 798             record.join(me);
 799
 800             sync = sync || record.phantom === true;
 801         }
 802
 803         if (me.snapshot) {
 804             me.snapshot.addAll(records);
 805         }
 806
 807         me.fireEvent('add', me, records, index);
 808         me.fireEvent('datachanged', me);
 809         if (me.autoSync &amp;&amp; sync) {
 810             me.sync();
 811         }
 812     },
 813
 814 <span id='Ext-data-Store-method-add'>    /**
 815 </span>     * Adds Model instances to the Store by instantiating them based on a JavaScript object. When adding already-
 816      * instantiated Models, use {@link #insert} instead. The instances will be added at the end of the existing collection.
 817      * This method accepts either a single argument array of Model instances or any number of model instance arguments.
 818      * Sample usage:
 819      *
 820 &lt;pre&gt;&lt;code&gt;
 821 myStore.add({some: 'data'}, {some: 'other data'});
 822 &lt;/code&gt;&lt;/pre&gt;
 823      *
 824      * @param {Object} data The data for each model
 825      * @return {Array} The array of newly created model instances
 826      */
 827     add: function(records) {
 828         //accept both a single-argument array of records, or any number of record arguments
 829         if (!Ext.isArray(records)) {
 830             records = Array.prototype.slice.apply(arguments);
 831         }
 832
 833         var me = this,
 834             i = 0,
 835             length = records.length,
 836             record;
 837
 838         for (; i &lt; length; i++) {
 839             record = me.createModel(records[i]);
 840             // reassign the model in the array in case it wasn't created yet
 841             records[i] = record;
 842         }
 843
 844         me.insert(me.data.length, records);
 845
 846         return records;
 847     },
 848
 849 <span id='Ext-data-Store-method-createModel'>    /**
 850 </span>     * Converts a literal to a model, if it's not a model already
 851      * @private
 852      * @param record {Ext.data.Model/Object} The record to create
 853      * @return {Ext.data.Model}
 854      */
 855     createModel: function(record) {
 856         if (!record.isModel) {
 857             record = Ext.ModelManager.create(record, this.model);
 858         }
 859
 860         return record;
 861     },
 862
 863 <span id='Ext-data-Store-method-each'>    /**
 864 </span>     * Calls the specified function for each of the {@link Ext.data.Model Records} in the cache.
 865      * @param {Function} fn The function to call. The {@link Ext.data.Model Record} is passed as the first parameter.
 866      * Returning &lt;tt&gt;false&lt;/tt&gt; aborts and exits the iteration.
 867      * @param {Object} scope (optional) The scope (&lt;code&gt;this&lt;/code&gt; reference) in which the function is executed.
 868      * Defaults to the current {@link Ext.data.Model Record} in the iteration.
 869      */
 870     each: function(fn, scope) {
 871         this.data.each(fn, scope);
 872     },
 873
 874 <span id='Ext-data-Store-method-remove'>    /**
 875 </span>     * Removes the given record from the Store, firing the 'remove' event for each instance that is removed, plus a single
 876      * 'datachanged' event after removal.
 877      * @param {Ext.data.Model/Array} records The Ext.data.Model instance or array of instances to remove
 878      */
 879     remove: function(records, /* private */ isMove) {
 880         if (!Ext.isArray(records)) {
 881             records = [records];
 882         }
 883
 884         /*
 885          * Pass the isMove parameter if we know we're going to be re-inserting this record
 886          */
 887         isMove = isMove === true;
 888         var me = this,
 889             sync = false,
 890             i = 0,
 891             length = records.length,
 892             isPhantom,
 893             index,
 894             record;
 895
 896         for (; i &lt; length; i++) {
 897             record = records[i];
 898             index = me.data.indexOf(record);
 899
 900             if (me.snapshot) {
 901                 me.snapshot.remove(record);
 902             }
 903
 904             if (index &gt; -1) {
 905                 isPhantom = record.phantom === true;
 906                 if (!isMove &amp;&amp; !isPhantom) {
 907                     // don't push phantom records onto removed
 908                     me.removed.push(record);
 909                 }
 910
 911                 record.unjoin(me);
 912                 me.data.remove(record);
 913                 sync = sync || !isPhantom;
 914
 915                 me.fireEvent('remove', me, record, index);
 916             }
 917         }
 918
 919         me.fireEvent('datachanged', me);
 920         if (!isMove &amp;&amp; me.autoSync &amp;&amp; sync) {
 921             me.sync();
 922         }
 923     },
 924
 925 <span id='Ext-data-Store-method-removeAt'>    /**
 926 </span>     * Removes the model instance at the given index
 927      * @param {Number} index The record index
 928      */
 929     removeAt: function(index) {
 930         var record = this.getAt(index);
 931
 932         if (record) {
 933             this.remove(record);
 934         }
 935     },
 936
 937 <span id='Ext-data-Store-method-load'>    /**
 938 </span>     * &lt;p&gt;Loads data into the Store via the configured {@link #proxy}. This uses the Proxy to make an
 939      * asynchronous call to whatever storage backend the Proxy uses, automatically adding the retrieved
 940      * instances into the Store and calling an optional callback if required. Example usage:&lt;/p&gt;
 941      *
 942 &lt;pre&gt;&lt;code&gt;
 943 store.load({
 944     scope   : this,
 945     callback: function(records, operation, success) {
 946         //the {@link Ext.data.Operation operation} object contains all of the details of the load operation
 947         console.log(records);
 948     }
 949 });
 950 &lt;/code&gt;&lt;/pre&gt;
 951      *
 952      * &lt;p&gt;If the callback scope does not need to be set, a function can simply be passed:&lt;/p&gt;
 953      *
 954 &lt;pre&gt;&lt;code&gt;
 955 store.load(function(records, operation, success) {
 956     console.log('loaded records');
 957 });
 958 &lt;/code&gt;&lt;/pre&gt;
 959      *
 960      * @param {Object/Function} options Optional config object, passed into the Ext.data.Operation object before loading.
 961      */
 962     load: function(options) {
 963         var me = this;
 964
 965         options = options || {};
 966
 967         if (Ext.isFunction(options)) {
 968             options = {
 969                 callback: options
 970             };
 971         }
 972
 973         Ext.applyIf(options, {
 974             groupers: me.groupers.items,
 975             page: me.currentPage,
 976             start: (me.currentPage - 1) * me.pageSize,
 977             limit: me.pageSize,
 978             addRecords: false
 979         });
 980
 981         return me.callParent([options]);
 982     },
 983
 984 <span id='Ext-data-Store-method-onProxyLoad'>    /**
 985 </span>     * @private
 986      * Called internally when a Proxy has completed a load request
 987      */
 988     onProxyLoad: function(operation) {
 989         var me = this,
 990             resultSet = operation.getResultSet(),
 991             records = operation.getRecords(),
 992             successful = operation.wasSuccessful();
 993
 994         if (resultSet) {
 995             me.totalCount = resultSet.total;
 996         }
 997
 998         if (successful) {
 999             me.loadRecords(records, operation);
1000         }
1001
1002         me.loading = false;
1003         me.fireEvent('load', me, records, successful);
1004
1005         //TODO: deprecate this event, it should always have been 'load' instead. 'load' is now documented, 'read' is not.
1006         //People are definitely using this so can't deprecate safely until 2.x
1007         me.fireEvent('read', me, records, operation.wasSuccessful());
1008
1009         //this is a callback that would have been passed to the 'read' function and is optional
1010         Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
1011     },
1012
1013 <span id='Ext-data-Store-method-onCreateRecords'>    /**
1014 </span>     * Create any new records when a write is returned from the server.
1015      * @private
1016      * @param {Array} records The array of new records
1017      * @param {Ext.data.Operation} operation The operation that just completed
1018      * @param {Boolean} success True if the operation was successful
1019      */
1020     onCreateRecords: function(records, operation, success) {
1021         if (success) {
1022             var i = 0,
1023                 data = this.data,
1024                 snapshot = this.snapshot,
1025                 length = records.length,
1026                 originalRecords = operation.records,
1027                 record,
1028                 original,
1029                 index;
1030
1031             /*
1032              * Loop over each record returned from the server. Assume they are
1033              * returned in order of how they were sent. If we find a matching
1034              * record, replace it with the newly created one.
1035              */
1036             for (; i &lt; length; ++i) {
1037                 record = records[i];
1038                 original = originalRecords[i];
1039                 if (original) {
1040                     index = data.indexOf(original);
1041                     if (index &gt; -1) {
1042                         data.removeAt(index);
1043                         data.insert(index, record);
1044                     }
1045                     if (snapshot) {
1046                         index = snapshot.indexOf(original);
1047                         if (index &gt; -1) {
1048                             snapshot.removeAt(index);
1049                             snapshot.insert(index, record);
1050                         }
1051                     }
1052                     record.phantom = false;
1053                     record.join(this);
1054                 }
1055             }
1056         }
1057     },
1058
1059 <span id='Ext-data-Store-method-onUpdateRecords'>    /**
1060 </span>     * Update any records when a write is returned from the server.
1061      * @private
1062      * @param {Array} records The array of updated records
1063      * @param {Ext.data.Operation} operation The operation that just completed
1064      * @param {Boolean} success True if the operation was successful
1065      */
1066     onUpdateRecords: function(records, operation, success){
1067         if (success) {
1068             var i = 0,
1069                 length = records.length,
1070                 data = this.data,
1071                 snapshot = this.snapshot,
1072                 record;
1073
1074             for (; i &lt; length; ++i) {
1075                 record = records[i];
1076                 data.replace(record);
1077                 if (snapshot) {
1078                     snapshot.replace(record);
1079                 }
1080                 record.join(this);
1081             }
1082         }
1083     },
1084
1085 <span id='Ext-data-Store-method-onDestroyRecords'>    /**
1086 </span>     * Remove any records when a write is returned from the server.
1087      * @private
1088      * @param {Array} records The array of removed records
1089      * @param {Ext.data.Operation} operation The operation that just completed
1090      * @param {Boolean} success True if the operation was successful
1091      */
1092     onDestroyRecords: function(records, operation, success){
1093         if (success) {
1094             var me = this,
1095                 i = 0,
1096                 length = records.length,
1097                 data = me.data,
1098                 snapshot = me.snapshot,
1099                 record;
1100
1101             for (; i &lt; length; ++i) {
1102                 record = records[i];
1103                 record.unjoin(me);
1104                 data.remove(record);
1105                 if (snapshot) {
1106                     snapshot.remove(record);
1107                 }
1108             }
1109             me.removed = [];
1110         }
1111     },
1112
1113     //inherit docs
1114     getNewRecords: function() {
1115         return this.data.filterBy(this.filterNew).items;
1116     },
1117
1118     //inherit docs
1119     getUpdatedRecords: function() {
1120         return this.data.filterBy(this.filterUpdated).items;
1121     },
1122
1123 <span id='Ext-data-Store-method-filter'>    /**
1124 </span>     * Filters the loaded set of records by a given set of filters.
1125      * @param {Mixed} filters The set of filters to apply to the data. These are stored internally on the store,
1126      * but the filtering itself is done on the Store's {@link Ext.util.MixedCollection MixedCollection}. See
1127      * MixedCollection's {@link Ext.util.MixedCollection#filter filter} method for filter syntax. Alternatively,
1128      * pass in a property string
1129      * @param {String} value Optional value to filter by (only if using a property string as the first argument)
1130      */
1131     filter: function(filters, value) {
1132         if (Ext.isString(filters)) {
1133             filters = {
1134                 property: filters,
1135                 value: value
1136             };
1137         }
1138
1139         var me = this,
1140             decoded = me.decodeFilters(filters),
1141             i = 0,
1142             doLocalSort = me.sortOnFilter &amp;&amp; !me.remoteSort,
1143             length = decoded.length;
1144
1145         for (; i &lt; length; i++) {
1146             me.filters.replace(decoded[i]);
1147         }
1148
1149         if (me.remoteFilter) {
1150             //the load function will pick up the new filters and request the filtered data from the proxy
1151             me.load();
1152         } else {
1153 <span id='Ext-data-Store-property-snapshot'>            /**
1154 </span>             * A pristine (unfiltered) collection of the records in this store. This is used to reinstate
1155              * records when a filter is removed or changed
1156              * @property snapshot
1157              * @type Ext.util.MixedCollection
1158              */
1159             if (me.filters.getCount()) {
1160                 me.snapshot = me.snapshot || me.data.clone();
1161                 me.data = me.data.filter(me.filters.items);
1162
1163                 if (doLocalSort) {
1164                     me.sort();
1165                 }
1166                 // fire datachanged event if it hasn't already been fired by doSort
1167                 if (!doLocalSort || me.sorters.length &lt; 1) {
1168                     me.fireEvent('datachanged', me);
1169                 }
1170             }
1171         }
1172     },
1173
1174 <span id='Ext-data-Store-method-clearFilter'>    /**
1175 </span>     * Revert to a view of the Record cache with no filtering applied.
1176      * @param {Boolean} suppressEvent If &lt;tt&gt;true&lt;/tt&gt; the filter is cleared silently without firing the
1177      * {@link #datachanged} event.
1178      */
1179     clearFilter: function(suppressEvent) {
1180         var me = this;
1181
1182         me.filters.clear();
1183
1184         if (me.remoteFilter) {
1185             me.load();
1186         } else if (me.isFiltered()) {
1187             me.data = me.snapshot.clone();
1188             delete me.snapshot;
1189
1190             if (suppressEvent !== true) {
1191                 me.fireEvent('datachanged', me);
1192             }
1193         }
1194     },
1195
1196 <span id='Ext-data-Store-method-isFiltered'>    /**
1197 </span>     * Returns true if this store is currently filtered
1198      * @return {Boolean}
1199      */
1200     isFiltered: function() {
1201         var snapshot = this.snapshot;
1202         return !! snapshot &amp;&amp; snapshot !== this.data;
1203     },
1204
1205 <span id='Ext-data-Store-method-filterBy'>    /**
1206 </span>     * Filter by a function. The specified function will be called for each
1207      * Record in this Store. If the function returns &lt;tt&gt;true&lt;/tt&gt; the Record is included,
1208      * otherwise it is filtered out.
1209      * @param {Function} fn The function to be called. It will be passed the following parameters:&lt;ul&gt;
1210      * &lt;li&gt;&lt;b&gt;record&lt;/b&gt; : Ext.data.Model&lt;p class=&quot;sub-desc&quot;&gt;The {@link Ext.data.Model record}
1211      * to test for filtering. Access field values using {@link Ext.data.Model#get}.&lt;/p&gt;&lt;/li&gt;
1212      * &lt;li&gt;&lt;b&gt;id&lt;/b&gt; : Object&lt;p class=&quot;sub-desc&quot;&gt;The ID of the Record passed.&lt;/p&gt;&lt;/li&gt;
1213      * &lt;/ul&gt;
1214      * @param {Object} scope (optional) The scope (&lt;code&gt;this&lt;/code&gt; reference) in which the function is executed. Defaults to this Store.
1215      */
1216     filterBy: function(fn, scope) {
1217         var me = this;
1218
1219         me.snapshot = me.snapshot || me.data.clone();
1220         me.data = me.queryBy(fn, scope || me);
1221         me.fireEvent('datachanged', me);
1222     },
1223
1224 <span id='Ext-data-Store-method-queryBy'>    /**
1225 </span>     * Query the cached records in this Store using a filtering function. The specified function
1226      * will be called with each record in this Store. If the function returns &lt;tt&gt;true&lt;/tt&gt; the record is
1227      * included in the results.
1228      * @param {Function} fn The function to be called. It will be passed the following parameters:&lt;ul&gt;
1229      * &lt;li&gt;&lt;b&gt;record&lt;/b&gt; : Ext.data.Model&lt;p class=&quot;sub-desc&quot;&gt;The {@link Ext.data.Model record}
1230      * to test for filtering. Access field values using {@link Ext.data.Model#get}.&lt;/p&gt;&lt;/li&gt;
1231      * &lt;li&gt;&lt;b&gt;id&lt;/b&gt; : Object&lt;p class=&quot;sub-desc&quot;&gt;The ID of the Record passed.&lt;/p&gt;&lt;/li&gt;
1232      * &lt;/ul&gt;
1233      * @param {Object} scope (optional) The scope (&lt;code&gt;this&lt;/code&gt; reference) in which the function is executed. Defaults to this Store.
1234      * @return {MixedCollection} Returns an Ext.util.MixedCollection of the matched records
1235      **/
1236     queryBy: function(fn, scope) {
1237         var me = this,
1238         data = me.snapshot || me.data;
1239         return data.filterBy(fn, scope || me);
1240     },
1241
1242 <span id='Ext-data-Store-method-loadData'>    /**
1243 </span>     * Loads an array of data straight into the Store
1244      * @param {Array} data Array of data to load. Any non-model instances will be cast into model instances first
1245      * @param {Boolean} append True to add the records to the existing records in the store, false to remove the old ones first
1246      */
1247     loadData: function(data, append) {
1248         var model = this.model,
1249             length = data.length,
1250             i,
1251             record;
1252
1253         //make sure each data element is an Ext.data.Model instance
1254         for (i = 0; i &lt; length; i++) {
1255             record = data[i];
1256
1257             if (! (record instanceof Ext.data.Model)) {
1258                 data[i] = Ext.ModelManager.create(record, model);
1259             }
1260         }
1261
1262         this.loadRecords(data, {addRecords: append});
1263     },
1264
1265 <span id='Ext-data-Store-method-loadRecords'>    /**
1266 </span>     * Loads an array of {@Ext.data.Model model} instances into the store, fires the datachanged event. This should only usually
1267      * be called internally when loading from the {@link Ext.data.proxy.Proxy Proxy}, when adding records manually use {@link #add} instead
1268      * @param {Array} records The array of records to load
1269      * @param {Object} options {addRecords: true} to add these records to the existing records, false to remove the Store's existing records first
1270      */
1271     loadRecords: function(records, options) {
1272         var me     = this,
1273             i      = 0,
1274             length = records.length;
1275
1276         options = options || {};
1277
1278
1279         if (!options.addRecords) {
1280             delete me.snapshot;
1281             me.data.clear();
1282         }
1283
1284         me.data.addAll(records);
1285
1286         //FIXME: this is not a good solution. Ed Spencer is totally responsible for this and should be forced to fix it immediately.
1287         for (; i &lt; length; i++) {
1288             if (options.start !== undefined) {
1289                 records[i].index = options.start + i;
1290
1291             }
1292             records[i].join(me);
1293         }
1294
1295         /*
1296          * this rather inelegant suspension and resumption of events is required because both the filter and sort functions
1297          * fire an additional datachanged event, which is not wanted. Ideally we would do this a different way. The first
1298          * datachanged event is fired by the call to this.add, above.
1299          */
1300         me.suspendEvents();
1301
1302         if (me.filterOnLoad &amp;&amp; !me.remoteFilter) {
1303             me.filter();
1304         }
1305
1306         if (me.sortOnLoad &amp;&amp; !me.remoteSort) {
1307             me.sort();
1308         }
1309
1310         me.resumeEvents();
1311         me.fireEvent('datachanged', me, records);
1312     },
1313
1314     // PAGING METHODS
1315 <span id='Ext-data-Store-method-loadPage'>    /**
1316 </span>     * Loads a given 'page' of data by setting the start and limit values appropriately. Internally this just causes a normal
1317      * load operation, passing in calculated 'start' and 'limit' params
1318      * @param {Number} page The number of the page to load
1319      */
1320     loadPage: function(page) {
1321         var me = this;
1322
1323         me.currentPage = page;
1324
1325         me.read({
1326             page: page,
1327             start: (page - 1) * me.pageSize,
1328             limit: me.pageSize,
1329             addRecords: !me.clearOnPageLoad
1330         });
1331     },
1332
1333 <span id='Ext-data-Store-method-nextPage'>    /**
1334 </span>     * Loads the next 'page' in the current data set
1335      */
1336     nextPage: function() {
1337         this.loadPage(this.currentPage + 1);
1338     },
1339
1340 <span id='Ext-data-Store-method-previousPage'>    /**
1341 </span>     * Loads the previous 'page' in the current data set
1342      */
1343     previousPage: function() {
1344         this.loadPage(this.currentPage - 1);
1345     },
1346
1347     // private
1348     clearData: function() {
1349         this.data.each(function(record) {
1350             record.unjoin();
1351         });
1352
1353         this.data.clear();
1354     },
1355
1356     // Buffering
1357 <span id='Ext-data-Store-method-prefetch'>    /**
1358 </span>     * Prefetches data the Store using its configured {@link #proxy}.
1359      * @param {Object} options Optional config object, passed into the Ext.data.Operation object before loading.
1360      * See {@link #load}
1361      */
1362     prefetch: function(options) {
1363         var me = this,
1364             operation,
1365             requestId = me.getRequestId();
1366
1367         options = options || {};
1368
1369         Ext.applyIf(options, {
1370             action : 'read',
1371             filters: me.filters.items,
1372             sorters: me.sorters.items,
1373             requestId: requestId
1374         });
1375         me.pendingRequests.push(requestId);
1376
1377         operation = Ext.create('Ext.data.Operation', options);
1378
1379         // HACK to implement loadMask support.
1380         //if (operation.blocking) {
1381         //    me.fireEvent('beforeload', me, operation);
1382         //}
1383         if (me.fireEvent('beforeprefetch', me, operation) !== false) {
1384             me.loading = true;
1385             me.proxy.read(operation, me.onProxyPrefetch, me);
1386         }
1387
1388         return me;
1389     },
1390
1391 <span id='Ext-data-Store-method-prefetchPage'>    /**
1392 </span>     * Prefetches a page of data.
1393      * @param {Number} page The page to prefetch
1394      * @param {Object} options Optional config object, passed into the Ext.data.Operation object before loading.
1395      * See {@link #load}
1396      * @param
1397      */
1398     prefetchPage: function(page, options) {
1399         var me = this,
1400             pageSize = me.pageSize,
1401             start = (page - 1) * me.pageSize,
1402             end = start + pageSize;
1403
1404         // Currently not requesting this page and range isn't already satisified
1405         if (Ext.Array.indexOf(me.pagesRequested, page) === -1 &amp;&amp; !me.rangeSatisfied(start, end)) {
1406             options = options || {};
1407             me.pagesRequested.push(page);
1408             Ext.applyIf(options, {
1409                 page : page,
1410                 start: start,
1411                 limit: pageSize,
1412                 callback: me.onWaitForGuarantee,
1413                 scope: me
1414             });
1415
1416             me.prefetch(options);
1417         }
1418
1419     },
1420
1421 <span id='Ext-data-Store-method-getRequestId'>    /**
1422 </span>     * Returns a unique requestId to track requests.
1423      * @private
1424      */
1425     getRequestId: function() {
1426         this.requestSeed = this.requestSeed || 1;
1427         return this.requestSeed++;
1428     },
1429
1430 <span id='Ext-data-Store-method-onProxyPrefetch'>    /**
1431 </span>     * Handles a success pre-fetch
1432      * @private
1433      * @param {Ext.data.Operation} operation The operation that completed
1434      */
1435     onProxyPrefetch: function(operation) {
1436         var me         = this,
1437             resultSet  = operation.getResultSet(),
1438             records    = operation.getRecords(),
1439
1440             successful = operation.wasSuccessful();
1441
1442         if (resultSet) {
1443             me.totalCount = resultSet.total;
1444             me.fireEvent('totalcountchange', me.totalCount);
1445         }
1446
1447         if (successful) {
1448             me.cacheRecords(records, operation);
1449         }
1450         Ext.Array.remove(me.pendingRequests, operation.requestId);
1451         if (operation.page) {
1452             Ext.Array.remove(me.pagesRequested, operation.page);
1453         }
1454
1455         me.loading = false;
1456         me.fireEvent('prefetch', me, records, successful, operation);
1457
1458         // HACK to support loadMask
1459         if (operation.blocking) {
1460             me.fireEvent('load', me, records, successful);
1461         }
1462
1463         //this is a callback that would have been passed to the 'read' function and is optional
1464         Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
1465     },
1466
1467 <span id='Ext-data-Store-method-cacheRecords'>    /**
1468 </span>     * Caches the records in the prefetch and stripes them with their server-side
1469      * index.
1470      * @private
1471      * @param {Array} records The records to cache
1472      * @param {Ext.data.Operation} The associated operation
1473      */
1474     cacheRecords: function(records, operation) {
1475         var me     = this,
1476             i      = 0,
1477             length = records.length,
1478             start  = operation ? operation.start : 0;
1479
1480         if (!Ext.isDefined(me.totalCount)) {
1481             me.totalCount = records.length;
1482             me.fireEvent('totalcountchange', me.totalCount);
1483         }
1484
1485         for (; i &lt; length; i++) {
1486             // this is the true index, not the viewIndex
1487             records[i].index = start + i;
1488         }
1489
1490         me.prefetchData.addAll(records);
1491         if (me.purgePageCount) {
1492             me.purgeRecords();
1493         }
1494
1495     },
1496
1497
1498 <span id='Ext-data-Store-method-purgeRecords'>    /**
1499 </span>     * Purge the least recently used records in the prefetch if the purgeCount
1500      * has been exceeded.
1501      */
1502     purgeRecords: function() {
1503         var me = this,
1504             prefetchCount = me.prefetchData.getCount(),
1505             purgeCount = me.purgePageCount * me.pageSize,
1506             numRecordsToPurge = prefetchCount - purgeCount - 1,
1507             i = 0;
1508
1509         for (; i &lt;= numRecordsToPurge; i++) {
1510             me.prefetchData.removeAt(0);
1511         }
1512     },
1513
1514 <span id='Ext-data-Store-method-rangeSatisfied'>    /**
1515 </span>     * Determines if the range has already been satisfied in the prefetchData.
1516      * @private
1517      * @param {Number} start The start index
1518      * @param {Number} end The end index in the range
1519      */
1520     rangeSatisfied: function(start, end) {
1521         var me = this,
1522             i = start,
1523             satisfied = true;
1524
1525         for (; i &lt; end; i++) {
1526             if (!me.prefetchData.getByKey(i)) {
1527                 satisfied = false;
1528                 //&lt;debug&gt;
1529                 if (end - i &gt; me.pageSize) {
1530                     Ext.Error.raise(&quot;A single page prefetch could never satisfy this request.&quot;);
1531                 }
1532                 //&lt;/debug&gt;
1533                 break;
1534             }
1535         }
1536         return satisfied;
1537     },
1538
1539 <span id='Ext-data-Store-method-getPageFromRecordIndex'>    /**
1540 </span>     * Determines the page from a record index
1541      * @param {Number} index The record index
1542      * @return {Number} The page the record belongs to
1543      */
1544     getPageFromRecordIndex: function(index) {
1545         return Math.floor(index / this.pageSize) + 1;
1546     },
1547
1548 <span id='Ext-data-Store-method-onGuaranteedRange'>    /**
1549 </span>     * Handles a guaranteed range being loaded
1550      * @private
1551      */
1552     onGuaranteedRange: function() {
1553         var me = this,
1554             totalCount = me.getTotalCount(),
1555             start = me.requestStart,
1556             end = ((totalCount - 1) &lt; me.requestEnd) ? totalCount - 1 : me.requestEnd,
1557             range = [],
1558             record,
1559             i = start;
1560
1561         //&lt;debug&gt;
1562         if (start &gt; end) {
1563             Ext.Error.raise(&quot;Start (&quot; + start + &quot;) was greater than end (&quot; + end + &quot;)&quot;);
1564         }
1565         //&lt;/debug&gt;
1566
1567         if (start !== me.guaranteedStart &amp;&amp; end !== me.guaranteedEnd) {
1568             me.guaranteedStart = start;
1569             me.guaranteedEnd = end;
1570
1571             for (; i &lt;= end; i++) {
1572                 record = me.prefetchData.getByKey(i);
1573                 //&lt;debug&gt;
1574                 if (!record) {
1575                     Ext.Error.raise(&quot;Record was not found and store said it was guaranteed&quot;);
1576                 }
1577                 //&lt;/debug&gt;
1578                 range.push(record);
1579             }
1580             me.fireEvent('guaranteedrange', range, start, end);
1581             if (me.cb) {
1582                 me.cb.call(me.scope || me, range);
1583             }
1584         }
1585
1586         me.unmask();
1587     },
1588
1589     // hack to support loadmask
1590     mask: function() {
1591         this.masked = true;
1592         this.fireEvent('beforeload');
1593     },
1594
1595     // hack to support loadmask
1596     unmask: function() {
1597         if (this.masked) {
1598             this.fireEvent('load');
1599         }
1600     },
1601
1602 <span id='Ext-data-Store-method-hasPendingRequests'>    /**
1603 </span>     * Returns the number of pending requests out.
1604      */
1605     hasPendingRequests: function() {
1606         return this.pendingRequests.length;
1607     },
1608
1609
1610     // wait until all requests finish, until guaranteeing the range.
1611     onWaitForGuarantee: function() {
1612         if (!this.hasPendingRequests()) {
1613             this.onGuaranteedRange();
1614         }
1615     },
1616
1617 <span id='Ext-data-Store-method-guaranteeRange'>    /**
1618 </span>     * Guarantee a specific range, this will load the store with a range (that
1619      * must be the pageSize or smaller) and take care of any loading that may
1620      * be necessary.
1621      */
1622     guaranteeRange: function(start, end, cb, scope) {
1623         //&lt;debug&gt;
1624         if (start &amp;&amp; end) {
1625             if (end - start &gt; this.pageSize) {
1626                 Ext.Error.raise({
1627                     start: start,
1628                     end: end,
1629                     pageSize: this.pageSize,
1630                     msg: &quot;Requested a bigger range than the specified pageSize&quot;
1631                 });
1632             }
1633         }
1634         //&lt;/debug&gt;
1635
1636         end = (end &gt; this.totalCount) ? this.totalCount - 1 : end;
1637
1638         var me = this,
1639             i = start,
1640             prefetchData = me.prefetchData,
1641             range = [],
1642             startLoaded = !!prefetchData.getByKey(start),
1643             endLoaded = !!prefetchData.getByKey(end),
1644             startPage = me.getPageFromRecordIndex(start),
1645             endPage = me.getPageFromRecordIndex(end);
1646
1647         me.cb = cb;
1648         me.scope = scope;
1649
1650         me.requestStart = start;
1651         me.requestEnd = end;
1652         // neither beginning or end are loaded
1653         if (!startLoaded || !endLoaded) {
1654             // same page, lets load it
1655             if (startPage === endPage) {
1656                 me.mask();
1657                 me.prefetchPage(startPage, {
1658                     //blocking: true,
1659                     callback: me.onWaitForGuarantee,
1660                     scope: me
1661                 });
1662             // need to load two pages
1663             } else {
1664                 me.mask();
1665                 me.prefetchPage(startPage, {
1666                     //blocking: true,
1667                     callback: me.onWaitForGuarantee,
1668                     scope: me
1669                 });
1670                 me.prefetchPage(endPage, {
1671                     //blocking: true,
1672                     callback: me.onWaitForGuarantee,
1673                     scope: me
1674                 });
1675             }
1676         // Request was already satisfied via the prefetch
1677         } else {
1678             me.onGuaranteedRange();
1679         }
1680     },
1681
1682     // because prefetchData is stored by index
1683     // this invalidates all of the prefetchedData
1684     sort: function() {
1685         var me = this,
1686             prefetchData = me.prefetchData,
1687             sorters,
1688             start,
1689             end,
1690             range;
1691
1692         if (me.buffered) {
1693             if (me.remoteSort) {
1694                 prefetchData.clear();
1695                 me.callParent(arguments);
1696             } else {
1697                 sorters = me.getSorters();
1698                 start = me.guaranteedStart;
1699                 end = me.guaranteedEnd;
1700
1701                 if (sorters.length) {
1702                     prefetchData.sort(sorters);
1703                     range = prefetchData.getRange();
1704                     prefetchData.clear();
1705                     me.cacheRecords(range);
1706                     delete me.guaranteedStart;
1707                     delete me.guaranteedEnd;
1708                     me.guaranteeRange(start, end);
1709                 }
1710                 me.callParent(arguments);
1711             }
1712         } else {
1713             me.callParent(arguments);
1714         }
1715     },
1716
1717     // overriden to provide striping of the indexes as sorting occurs.
1718     // this cannot be done inside of sort because datachanged has already
1719     // fired and will trigger a repaint of the bound view.
1720     doSort: function(sorterFn) {
1721         var me = this;
1722         if (me.remoteSort) {
1723             //the load function will pick up the new sorters and request the sorted data from the proxy
1724             me.load();
1725         } else {
1726             me.data.sortBy(sorterFn);
1727             if (!me.buffered) {
1728                 var range = me.getRange(),
1729                     ln = range.length,
1730                     i  = 0;
1731                 for (; i &lt; ln; i++) {
1732                     range[i].index = i;
1733                 }
1734             }
1735             me.fireEvent('datachanged', me);
1736         }
1737     },
1738
1739 <span id='Ext-data-Store-method-find'>    /**
1740 </span>     * Finds the index of the first matching Record in this store by a specific field value.
1741      * @param {String} fieldName The name of the Record field to test.
1742      * @param {String/RegExp} value Either a string that the field value
1743      * should begin with, or a RegExp to test against the field.
1744      * @param {Number} startIndex (optional) The index to start searching at
1745      * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning
1746      * @param {Boolean} caseSensitive (optional) True for case sensitive comparison
1747      * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false.
1748      * @return {Number} The matched index or -1
1749      */
1750     find: function(property, value, start, anyMatch, caseSensitive, exactMatch) {
1751         var fn = this.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch);
1752         return fn ? this.data.findIndexBy(fn, null, start) : -1;
1753     },
1754
1755 <span id='Ext-data-Store-method-findRecord'>    /**
1756 </span>     * Finds the first matching Record in this store by a specific field value.
1757      * @param {String} fieldName The name of the Record field to test.
1758      * @param {String/RegExp} value Either a string that the field value
1759      * should begin with, or a RegExp to test against the field.
1760      * @param {Number} startIndex (optional) The index to start searching at
1761      * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning
1762      * @param {Boolean} caseSensitive (optional) True for case sensitive comparison
1763      * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false.
1764      * @return {Ext.data.Model} The matched record or null
1765      */
1766     findRecord: function() {
1767         var me = this,
1768             index = me.find.apply(me, arguments);
1769         return index !== -1 ? me.getAt(index) : null;
1770     },
1771
1772 <span id='Ext-data-Store-method-createFilterFn'>    /**
1773 </span>     * @private
1774      * Returns a filter function used to test a the given property's value. Defers most of the work to
1775      * Ext.util.MixedCollection's createValueMatcher function
1776      * @param {String} property The property to create the filter function for
1777      * @param {String/RegExp} value The string/regex to compare the property value to
1778      * @param {Boolean} anyMatch True if we don't care if the filter value is not the full value (defaults to false)
1779      * @param {Boolean} caseSensitive True to create a case-sensitive regex (defaults to false)
1780      * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false.
1781      * Ignored if anyMatch is true.
1782      */
1783     createFilterFn: function(property, value, anyMatch, caseSensitive, exactMatch) {
1784         if (Ext.isEmpty(value)) {
1785             return false;
1786         }
1787         value = this.data.createValueMatcher(value, anyMatch, caseSensitive, exactMatch);
1788         return function(r) {
1789             return value.test(r.data[property]);
1790         };
1791     },
1792
1793 <span id='Ext-data-Store-method-findExact'>    /**
1794 </span>     * Finds the index of the first matching Record in this store by a specific field value.
1795      * @param {String} fieldName The name of the Record field to test.
1796      * @param {Mixed} value The value to match the field against.
1797      * @param {Number} startIndex (optional) The index to start searching at
1798      * @return {Number} The matched index or -1
1799      */
1800     findExact: function(property, value, start) {
1801         return this.data.findIndexBy(function(rec) {
1802             return rec.get(property) === value;
1803         },
1804         this, start);
1805     },
1806
1807 <span id='Ext-data-Store-method-findBy'>    /**
1808 </span>     * Find the index of the first matching Record in this Store by a function.
1809      * If the function returns &lt;tt&gt;true&lt;/tt&gt; it is considered a match.
1810      * @param {Function} fn The function to be called. It will be passed the following parameters:&lt;ul&gt;
1811      * &lt;li&gt;&lt;b&gt;record&lt;/b&gt; : Ext.data.Model&lt;p class=&quot;sub-desc&quot;&gt;The {@link Ext.data.Model record}
1812      * to test for filtering. Access field values using {@link Ext.data.Model#get}.&lt;/p&gt;&lt;/li&gt;
1813      * &lt;li&gt;&lt;b&gt;id&lt;/b&gt; : Object&lt;p class=&quot;sub-desc&quot;&gt;The ID of the Record passed.&lt;/p&gt;&lt;/li&gt;
1814      * &lt;/ul&gt;
1815      * @param {Object} scope (optional) The scope (&lt;code&gt;this&lt;/code&gt; reference) in which the function is executed. Defaults to this Store.
1816      * @param {Number} startIndex (optional) The index to start searching at
1817      * @return {Number} The matched index or -1
1818      */
1819     findBy: function(fn, scope, start) {
1820         return this.data.findIndexBy(fn, scope, start);
1821     },
1822
1823 <span id='Ext-data-Store-method-collect'>    /**
1824 </span>     * Collects unique values for a particular dataIndex from this store.
1825      * @param {String} dataIndex The property to collect
1826      * @param {Boolean} allowNull (optional) Pass true to allow null, undefined or empty string values
1827      * @param {Boolean} bypassFilter (optional) Pass true to collect from all records, even ones which are filtered
1828      * @return {Array} An array of the unique values
1829      **/
1830     collect: function(dataIndex, allowNull, bypassFilter) {
1831         var me = this,
1832             data = (bypassFilter === true &amp;&amp; me.snapshot) ? me.snapshot: me.data;
1833
1834         return data.collect(dataIndex, 'data', allowNull);
1835     },
1836
1837 <span id='Ext-data-Store-method-getCount'>    /**
1838 </span>     * Gets the number of cached records.
1839      * &lt;p&gt;If using paging, this may not be the total size of the dataset. If the data object
1840      * used by the Reader contains the dataset size, then the {@link #getTotalCount} function returns
1841      * the dataset size.  &lt;b&gt;Note&lt;/b&gt;: see the Important note in {@link #load}.&lt;/p&gt;
1842      * @return {Number} The number of Records in the Store's cache.
1843      */
1844     getCount: function() {
1845         return this.data.length || 0;
1846     },
1847
1848 <span id='Ext-data-Store-method-getTotalCount'>    /**
1849 </span>     * Returns the total number of {@link Ext.data.Model Model} instances that the {@link Ext.data.proxy.Proxy Proxy}
1850      * indicates exist. This will usually differ from {@link #getCount} when using paging - getCount returns the
1851      * number of records loaded into the Store at the moment, getTotalCount returns the number of records that
1852      * could be loaded into the Store if the Store contained all data
1853      * @return {Number} The total number of Model instances available via the Proxy
1854      */
1855     getTotalCount: function() {
1856         return this.totalCount;
1857     },
1858
1859 <span id='Ext-data-Store-method-getAt'>    /**
1860 </span>     * Get the Record at the specified index.
1861      * @param {Number} index The index of the Record to find.
1862      * @return {Ext.data.Model} The Record at the passed index. Returns undefined if not found.
1863      */
1864     getAt: function(index) {
1865         return this.data.getAt(index);
1866     },
1867
1868 <span id='Ext-data-Store-method-getRange'>    /**
1869 </span>     * Returns a range of Records between specified indices.
1870      * @param {Number} startIndex (optional) The starting index (defaults to 0)
1871      * @param {Number} endIndex (optional) The ending index (defaults to the last Record in the Store)
1872      * @return {Ext.data.Model[]} An array of Records
1873      */
1874     getRange: function(start, end) {
1875         return this.data.getRange(start, end);
1876     },
1877
1878 <span id='Ext-data-Store-method-getById'>    /**
1879 </span>     * Get the Record with the specified id.
1880      * @param {String} id The id of the Record to find.
1881      * @return {Ext.data.Model} The Record with the passed id. Returns undefined if not found.
1882      */
1883     getById: function(id) {
1884         return (this.snapshot || this.data).findBy(function(record) {
1885             return record.getId() === id;
1886         });
1887     },
1888
1889 <span id='Ext-data-Store-method-indexOf'>    /**
1890 </span>     * Get the index within the cache of the passed Record.
1891      * @param {Ext.data.Model} record The Ext.data.Model object to find.
1892      * @return {Number} The index of the passed Record. Returns -1 if not found.
1893      */
1894     indexOf: function(record) {
1895         return this.data.indexOf(record);
1896     },
1897
1898
1899 <span id='Ext-data-Store-method-indexOfTotal'>    /**
1900 </span>     * Get the index within the entire dataset. From 0 to the totalCount.
1901      * @param {Ext.data.Model} record The Ext.data.Model object to find.
1902      * @return {Number} The index of the passed Record. Returns -1 if not found.
1903      */
1904     indexOfTotal: function(record) {
1905         return record.index || this.indexOf(record);
1906     },
1907
1908 <span id='Ext-data-Store-method-indexOfId'>    /**
1909 </span>     * Get the index within the cache of the Record with the passed id.
1910      * @param {String} id The id of the Record to find.
1911      * @return {Number} The index of the Record. Returns -1 if not found.
1912      */
1913     indexOfId: function(id) {
1914         return this.data.indexOfKey(id);
1915     },
1916
1917 <span id='Ext-data-Store-method-removeAll'>    /**
1918 </span>     * Remove all items from the store.
1919      * @param {Boolean} silent Prevent the `clear` event from being fired.
1920      */
1921     removeAll: function(silent) {
1922         var me = this;
1923
1924         me.clearData();
1925         if (me.snapshot) {
1926             me.snapshot.clear();
1927         }
1928         if (silent !== true) {
1929             me.fireEvent('clear', me);
1930         }
1931     },
1932
1933     /*
1934      * Aggregation methods
1935      */
1936
1937 <span id='Ext-data-Store-method-first'>    /**
1938 </span>     * Convenience function for getting the first model instance in the store
1939      * @param {Boolean} grouped (Optional) True to perform the operation for each group
1940      * in the store. The value returned will be an object literal with the key being the group
1941      * name and the first record being the value. The grouped parameter is only honored if
1942      * the store has a groupField.
1943      * @return {Ext.data.Model/undefined} The first model instance in the store, or undefined
1944      */
1945     first: function(grouped) {
1946         var me = this;
1947
1948         if (grouped &amp;&amp; me.isGrouped()) {
1949             return me.aggregate(function(records) {
1950                 return records.length ? records[0] : undefined;
1951             }, me, true);
1952         } else {
1953             return me.data.first();
1954         }
1955     },
1956
1957 <span id='Ext-data-Store-method-last'>    /**
1958 </span>     * Convenience function for getting the last model instance in the store
1959      * @param {Boolean} grouped (Optional) True to perform the operation for each group
1960      * in the store. The value returned will be an object literal with the key being the group
1961      * name and the last record being the value. The grouped parameter is only honored if
1962      * the store has a groupField.
1963      * @return {Ext.data.Model/undefined} The last model instance in the store, or undefined
1964      */
1965     last: function(grouped) {
1966         var me = this;
1967
1968         if (grouped &amp;&amp; me.isGrouped()) {
1969             return me.aggregate(function(records) {
1970                 var len = records.length;
1971                 return len ? records[len - 1] : undefined;
1972             }, me, true);
1973         } else {
1974             return me.data.last();
1975         }
1976     },
1977
1978 <span id='Ext-data-Store-method-sum'>    /**
1979 </span>     * Sums the value of &lt;tt&gt;property&lt;/tt&gt; for each {@link Ext.data.Model record} between &lt;tt&gt;start&lt;/tt&gt;
1980      * and &lt;tt&gt;end&lt;/tt&gt; and returns the result.
1981      * @param {String} field A field in each record
1982      * @param {Boolean} grouped (Optional) True to perform the operation for each group
1983      * in the store. The value returned will be an object literal with the key being the group
1984      * name and the sum for that group being the value. The grouped parameter is only honored if
1985      * the store has a groupField.
1986      * @return {Number} The sum
1987      */
1988     sum: function(field, grouped) {
1989         var me = this;
1990
1991         if (grouped &amp;&amp; me.isGrouped()) {
1992             return me.aggregate(me.getSum, me, true, [field]);
1993         } else {
1994             return me.getSum(me.data.items, field);
1995         }
1996     },
1997
1998     // @private, see sum
1999     getSum: function(records, field) {
2000         var total = 0,
2001             i = 0,
2002             len = records.length;
2003
2004         for (; i &lt; len; ++i) {
2005             total += records[i].get(field);
2006         }
2007
2008         return total;
2009     },
2010
2011 <span id='Ext-data-Store-method-count'>    /**
2012 </span>     * Gets the count of items in the store.
2013      * @param {Boolean} grouped (Optional) True to perform the operation for each group
2014      * in the store. The value returned will be an object literal with the key being the group
2015      * name and the count for each group being the value. The grouped parameter is only honored if
2016      * the store has a groupField.
2017      * @return {Number} the count
2018      */
2019     count: function(grouped) {
2020         var me = this;
2021
2022         if (grouped &amp;&amp; me.isGrouped()) {
2023             return me.aggregate(function(records) {
2024                 return records.length;
2025             }, me, true);
2026         } else {
2027             return me.getCount();
2028         }
2029     },
2030
2031 <span id='Ext-data-Store-method-min'>    /**
2032 </span>     * Gets the minimum value in the store.
2033      * @param {String} field The field in each record
2034      * @param {Boolean} grouped (Optional) True to perform the operation for each group
2035      * in the store. The value returned will be an object literal with the key being the group
2036      * name and the minimum in the group being the value. The grouped parameter is only honored if
2037      * the store has a groupField.
2038      * @return {Mixed/undefined} The minimum value, if no items exist, undefined.
2039      */
2040     min: function(field, grouped) {
2041         var me = this;
2042
2043         if (grouped &amp;&amp; me.isGrouped()) {
2044             return me.aggregate(me.getMin, me, true, [field]);
2045         } else {
2046             return me.getMin(me.data.items, field);
2047         }
2048     },
2049
2050     // @private, see min
2051     getMin: function(records, field){
2052         var i = 1,
2053             len = records.length,
2054             value, min;
2055
2056         if (len &gt; 0) {
2057             min = records[0].get(field);
2058         }
2059
2060         for (; i &lt; len; ++i) {
2061             value = records[i].get(field);
2062             if (value &lt; min) {
2063                 min = value;
2064             }
2065         }
2066         return min;
2067     },
2068
2069 <span id='Ext-data-Store-method-max'>    /**
2070 </span>     * Gets the maximum value in the store.
2071      * @param {String} field The field in each record
2072      * @param {Boolean} grouped (Optional) True to perform the operation for each group
2073      * in the store. The value returned will be an object literal with the key being the group
2074      * name and the maximum in the group being the value. The grouped parameter is only honored if
2075      * the store has a groupField.
2076      * @return {Mixed/undefined} The maximum value, if no items exist, undefined.
2077      */
2078     max: function(field, grouped) {
2079         var me = this;
2080
2081         if (grouped &amp;&amp; me.isGrouped()) {
2082             return me.aggregate(me.getMax, me, true, [field]);
2083         } else {
2084             return me.getMax(me.data.items, field);
2085         }
2086     },
2087
2088     // @private, see max
2089     getMax: function(records, field) {
2090         var i = 1,
2091             len = records.length,
2092             value,
2093             max;
2094
2095         if (len &gt; 0) {
2096             max = records[0].get(field);
2097         }
2098
2099         for (; i &lt; len; ++i) {
2100             value = records[i].get(field);
2101             if (value &gt; max) {
2102                 max = value;
2103             }
2104         }
2105         return max;
2106     },
2107
2108 <span id='Ext-data-Store-method-average'>    /**
2109 </span>     * Gets the average value in the store.
2110      * @param {String} field The field in each record
2111      * @param {Boolean} grouped (Optional) True to perform the operation for each group
2112      * in the store. The value returned will be an object literal with the key being the group
2113      * name and the group average being the value. The grouped parameter is only honored if
2114      * the store has a groupField.
2115      * @return {Mixed/undefined} The average value, if no items exist, 0.
2116      */
2117     average: function(field, grouped) {
2118         var me = this;
2119         if (grouped &amp;&amp; me.isGrouped()) {
2120             return me.aggregate(me.getAverage, me, true, [field]);
2121         } else {
2122             return me.getAverage(me.data.items, field);
2123         }
2124     },
2125
2126     // @private, see average
2127     getAverage: function(records, field) {
2128         var i = 0,
2129             len = records.length,
2130             sum = 0;
2131
2132         if (records.length &gt; 0) {
2133             for (; i &lt; len; ++i) {
2134                 sum += records[i].get(field);
2135             }
2136             return sum / len;
2137         }
2138         return 0;
2139     },
2140
2141 <span id='Ext-data-Store-method-aggregate'>    /**
2142 </span>     * Runs the aggregate function for all the records in the store.
2143      * @param {Function} fn The function to execute. The function is called with a single parameter,
2144      * an array of records for that group.
2145      * @param {Object} scope (optional) The scope to execute the function in. Defaults to the store.
2146      * @param {Boolean} grouped (Optional) True to perform the operation for each group
2147      * in the store. The value returned will be an object literal with the key being the group
2148      * name and the group average being the value. The grouped parameter is only honored if
2149      * the store has a groupField.
2150      * @param {Array} args (optional) Any arguments to append to the function call
2151      * @return {Object} An object literal with the group names and their appropriate values.
2152      */
2153     aggregate: function(fn, scope, grouped, args) {
2154         args = args || [];
2155         if (grouped &amp;&amp; this.isGrouped()) {
2156             var groups = this.getGroups(),
2157                 i = 0,
2158                 len = groups.length,
2159                 out = {},
2160                 group;
2161
2162             for (; i &lt; len; ++i) {
2163                 group = groups[i];
2164                 out[group.name] = fn.apply(scope || this, [group.children].concat(args));
2165             }
2166             return out;
2167         } else {
2168             return fn.apply(scope || this, [this.data.items].concat(args));
2169         }
2170     }
2171 });
2172 </pre>
2173 </body>
2174 </html>