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