docs/source/Store2.html

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