-<!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'>/**
-</span></span> * @author Ed Spencer
+<!DOCTYPE html>
+<html>
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <title>The source code</title>
+ <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
+ <script type="text/javascript" src="../prettify/prettify.js"></script>
+ <style type="text/css">
+ .highlight { display: block; background-color: #ddd; }
+ </style>
+ <script type="text/javascript">
+ function highlight() {
+ document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
+ }
+ </script>
+</head>
+<body onload="prettyPrint(); highlight();">
+ <pre class="prettyprint lang-js"><span id='Ext-data-Store'>/**
+</span> * @author Ed Spencer
* @class Ext.data.Store
* @extends Ext.data.AbstractStore
*
* <li>{@link Ext.data.reader.Reader Reader} - used by any subclass of {@link Ext.data.proxy.Server ServerProxy} to read a response</li>
* </ul>
*
- * @constructor
- * @param {Object} config Optional config object
*/
Ext.define('Ext.data.Store', {
extend: 'Ext.data.AbstractStore',
requires: ['Ext.ModelManager', 'Ext.data.Model', 'Ext.util.Grouper'],
uses: ['Ext.data.proxy.Memory'],
-<span id='Ext-data.Store-cfg-remoteSort'> /**
+<span id='Ext-data-Store-cfg-remoteSort'> /**
</span> * @cfg {Boolean} remoteSort
* True to defer any sorting operation to the server. If false, sorting is done locally on the client. Defaults to <tt>false</tt>.
*/
remoteSort: false,
-<span id='Ext-data.Store-cfg-remoteFilter'> /**
+<span id='Ext-data-Store-cfg-remoteFilter'> /**
</span> * @cfg {Boolean} remoteFilter
* True to defer any filtering operation to the server. If false, filtering is done locally on the client. Defaults to <tt>false</tt>.
*/
remoteFilter: false,
-<span id='Ext-data.Store-cfg-remoteGroup'> /**
+<span id='Ext-data-Store-cfg-remoteGroup'> /**
</span> * @cfg {Boolean} remoteGroup
* True if the grouping should apply on the server side, false if it is local only (defaults to false). If the
* grouping is local, it can be applied immediately to the data. If it is remote, then it will simply act as a
*/
remoteGroup : false,
-<span id='Ext-data.Store-cfg-proxy'> /**
+<span id='Ext-data-Store-cfg-proxy'> /**
</span> * @cfg {String/Ext.data.proxy.Proxy/Object} proxy The Proxy to use for this Store. This can be either a string, a config
* object or a Proxy instance - see {@link #setProxy} for details.
*/
-<span id='Ext-data.Store-cfg-data'> /**
+<span id='Ext-data-Store-cfg-data'> /**
</span> * @cfg {Array} data Optional array of Model instances or data objects to load locally. See "Inline data" above for details.
*/
-<span id='Ext-data.Store-cfg-model'> /**
+<span id='Ext-data-Store-cfg-model'> /**
</span> * @cfg {String} model The {@link Ext.data.Model} associated with this store
*/
-<span id='Ext-data.Store-property-groupField'> /**
+<span id='Ext-data-Store-property-groupField'> /**
</span> * The (optional) field by which to group data in the store. Internally, grouping is very similar to sorting - the
* groupField and {@link #groupDir} are injected as the first sorter (see {@link #sort}). Stores support a single
* level of grouping, and groups can be fetched via the {@link #getGroups} method.
*/
groupField: undefined,
-<span id='Ext-data.Store-property-groupDir'> /**
+<span id='Ext-data-Store-property-groupDir'> /**
</span> * The direction in which sorting should be applied when grouping. Defaults to "ASC" - the other supported value is "DESC"
* @property groupDir
* @type String
*/
groupDir: "ASC",
-<span id='Ext-data.Store-property-pageSize'> /**
-</span> * The number of records considered to form a 'page'. This is used to power the built-in
+<span id='Ext-data-Store-cfg-pageSize'> /**
+</span> * @cfg {Number} pageSize
+ * The number of records considered to form a 'page'. This is used to power the built-in
* paging using the nextPage and previousPage functions. Defaults to 25.
- * @property pageSize
- * @type Number
*/
pageSize: 25,
-<span id='Ext-data.Store-property-currentPage'> /**
+<span id='Ext-data-Store-property-currentPage'> /**
</span> * The page that the Store has most recently loaded (see {@link #loadPage})
* @property currentPage
* @type Number
*/
currentPage: 1,
-<span id='Ext-data.Store-cfg-clearOnPageLoad'> /**
+<span id='Ext-data-Store-cfg-clearOnPageLoad'> /**
</span> * @cfg {Boolean} clearOnPageLoad True to empty the store when loading another page via {@link #loadPage},
* {@link #nextPage} or {@link #previousPage} (defaults to true). Setting to false keeps existing records, allowing
* large data sets to be loaded one page at a time but rendered all together.
*/
clearOnPageLoad: true,
-<span id='Ext-data.Store-property-loading'> /**
+<span id='Ext-data-Store-property-loading'> /**
</span> * True if the Store is currently loading via its Proxy
* @property loading
* @type Boolean
*/
loading: false,
-<span id='Ext-data.Store-cfg-sortOnFilter'> /**
+<span id='Ext-data-Store-cfg-sortOnFilter'> /**
</span> * @cfg {Boolean} sortOnFilter For local filtering only, causes {@link #sort} to be called whenever {@link #filter} is called,
* causing the sorters to be reapplied after filtering. Defaults to true
*/
sortOnFilter: true,
-<span id='Ext-data.Store-cfg-buffered'> /**
+<span id='Ext-data-Store-cfg-buffered'> /**
</span> * @cfg {Boolean} buffered
* Allow the store to buffer and pre-fetch pages of records. This is to be used in conjunction with a view will
* tell the store to pre-fetch records ahead of a time.
*/
buffered: false,
-<span id='Ext-data.Store-cfg-purgePageCount'> /**
+<span id='Ext-data-Store-cfg-purgePageCount'> /**
</span> * @cfg {Number} purgePageCount
* The number of pages to keep in the cache before purging additional records. A value of 0 indicates to never purge the prefetched data.
* This option is only relevant when the {@link #buffered} option is set to true.
isStore: true,
- //documented above
+<span id='Ext-data-Store-method-constructor'> /**
+</span> * Creates the store.
+ * @param {Object} config (optional) Config object
+ */
constructor: function(config) {
config = config || {};
var me = this,
- groupers = config.groupers,
+ groupers = config.groupers || me.groupers,
+ groupField = config.groupField || me.groupField,
proxy,
data;
}
me.addEvents(
-<span id='Ext-data.Store-event-beforeprefetch'> /**
+<span id='Ext-data-Store-event-beforeprefetch'> /**
</span> * @event beforeprefetch
* Fires before a prefetch occurs. Return false to cancel.
* @param {Ext.data.store} this
* @param {Ext.data.Operation} operation The associated operation
*/
'beforeprefetch',
-<span id='Ext-data.Store-event-groupchange'> /**
+<span id='Ext-data-Store-event-groupchange'> /**
</span> * @event groupchange
* Fired whenever the grouping in the grid changes
* @param {Ext.data.Store} store The store
* @param {Array} groupers The array of grouper objects
*/
'groupchange',
-<span id='Ext-data.Store-event-load'> /**
+<span id='Ext-data-Store-event-load'> /**
</span> * @event load
* Fires whenever records have been prefetched
* @param {Ext.data.store} this
);
data = config.data || me.data;
-<span id='Ext-data.Store-property-data'> /**
+<span id='Ext-data-Store-property-data'> /**
</span> * The MixedCollection that holds this store's local cache of records
* @property data
* @type Ext.util.MixedCollection
delete config.data;
}
- if (!groupers && config.groupField) {
+ if (!groupers && groupField) {
groupers = [{
- property : config.groupField,
- direction: config.groupDir
+ property : groupField,
+ direction: config.groupDir || me.groupDir
}];
}
delete config.groupers;
-<span id='Ext-data.Store-property-groupers'> /**
+<span id='Ext-data-Store-property-groupers'> /**
</span> * The collection of {@link Ext.util.Grouper Groupers} currently applied to this Store
* @property groupers
* @type Ext.util.MixedCollection
me.groupers.addAll(me.decodeGroupers(groupers));
this.callParent([config]);
+ // don't use *config* anymore from here on... use *me* instead...
if (me.groupers.items.length) {
me.sort(me.groupers.items, 'prepend', false);
this.sort(this.groupers.items, 'prepend', false);
},
-<span id='Ext-data.Store-method-decodeGroupers'> /**
+<span id='Ext-data-Store-method-decodeGroupers'> /**
</span> * @private
* Normalizes an array of grouper objects, ensuring that they are all Ext.util.Grouper instances
* @param {Array} groupers The groupers array
return groupers;
},
-<span id='Ext-data.Store-method-group'> /**
+<span id='Ext-data-Store-method-group'> /**
</span> * Group data in the store
* @param {String|Array} groupers Either a string name of one of the fields in this Store's configured {@link Ext.data.Model Model},
* or an Array of grouper configurations.
}
},
-<span id='Ext-data.Store-method-clearGrouping'> /**
+<span id='Ext-data-Store-method-clearGrouping'> /**
</span> * Clear any groupers in the store
*/
clearGrouping: function(){
}
},
-<span id='Ext-data.Store-method-isGrouped'> /**
+<span id='Ext-data-Store-method-isGrouped'> /**
</span> * Checks if the store is currently grouped
* @return {Boolean} True if the store is grouped.
*/
return this.groupers.getCount() > 0;
},
-<span id='Ext-data.Store-method-fireGroupChange'> /**
+<span id='Ext-data-Store-method-fireGroupChange'> /**
</span> * Fires the groupchange event. Abstracted out so we can use it
* as a callback
* @private
this.fireEvent('groupchange', this, this.groupers);
},
-<span id='Ext-data.Store-method-getGroups'> /**
+<span id='Ext-data-Store-method-getGroups'> /**
</span> * Returns an object containing the result of applying grouping to the records in this store. See {@link #groupField},
* {@link #groupDir} and {@link #getGroupString}. Example for a store containing records with a color field:
<pre><code>
return requestGroupString ? pointers[requestGroupString] : groups;
},
-<span id='Ext-data.Store-method-getGroupsForGrouper'> /**
+<span id='Ext-data-Store-method-getGroupsForGrouper'> /**
</span> * @private
* For a given set of records and a Grouper, returns an array of arrays - each of which is the set of records
* matching a certain group.
return groups;
},
-<span id='Ext-data.Store-method-getGroupsForGrouperIndex'> /**
+<span id='Ext-data-Store-method-getGroupsForGrouperIndex'> /**
</span> * @private
* This is used recursively to gather the records into the configured Groupers. The data MUST have been sorted for
* this to work properly (see {@link #getGroupData} and {@link #getGroupsForGrouper}) Most of the work is done by
return groups;
},
-<span id='Ext-data.Store-method-getGroupData'> /**
+<span id='Ext-data-Store-method-getGroupData'> /**
</span> * @private
* <p>Returns records grouped by the configured {@link #groupers grouper} configuration. Sample return value (in
* this case grouping by genre and then author in a fictional books dataset):</p>
return me.getGroupsForGrouperIndex(me.data.items, 0);
},
-<span id='Ext-data.Store-method-getGroupString'> /**
+<span id='Ext-data-Store-method-getGroupString'> /**
</span> * <p>Returns the string to group on for a given model instance. The default implementation of this method returns
* the model's {@link #groupField}, but this can be overridden to group by an arbitrary string. For example, to
* group by the first letter of a model's 'name' field, use the following code:</p>
}
return '';
},
-<span id='Ext-data.Store-method-insert'> /**
+<span id='Ext-data-Store-method-insert'> /**
</span> * Inserts Model instances into the Store at the given index and fires the {@link #add} event.
* See also <code>{@link #add}</code>.
* @param {Number} index The start index at which to insert the passed Records.
}
},
-<span id='Ext-data.Store-method-add'> /**
+<span id='Ext-data-Store-method-add'> /**
</span> * Adds Model instances to the Store by instantiating them based on a JavaScript object. When adding already-
* instantiated Models, use {@link #insert} instead. The instances will be added at the end of the existing collection.
* This method accepts either a single argument array of Model instances or any number of model instance arguments.
return records;
},
-<span id='Ext-data.Store-method-createModel'> /**
+<span id='Ext-data-Store-method-createModel'> /**
</span> * Converts a literal to a model, if it's not a model already
* @private
* @param record {Ext.data.Model/Object} The record to create
return record;
},
-<span id='Ext-data.Store-method-each'> /**
+<span id='Ext-data-Store-method-each'> /**
</span> * Calls the specified function for each of the {@link Ext.data.Model Records} in the cache.
* @param {Function} fn The function to call. The {@link Ext.data.Model Record} is passed as the first parameter.
* Returning <tt>false</tt> aborts and exits the iteration.
this.data.each(fn, scope);
},
-<span id='Ext-data.Store-method-remove'> /**
+<span id='Ext-data-Store-method-remove'> /**
</span> * Removes the given record from the Store, firing the 'remove' event for each instance that is removed, plus a single
* 'datachanged' event after removal.
* @param {Ext.data.Model/Array} records The Ext.data.Model instance or array of instances to remove
}
},
-<span id='Ext-data.Store-method-removeAt'> /**
+<span id='Ext-data-Store-method-removeAt'> /**
</span> * Removes the model instance at the given index
* @param {Number} index The record index
*/
}
},
-<span id='Ext-data.Store-method-load'> /**
+<span id='Ext-data-Store-method-load'> /**
</span> * <p>Loads data into the Store via the configured {@link #proxy}. This uses the Proxy to make an
* asynchronous call to whatever storage backend the Proxy uses, automatically adding the retrieved
* instances into the Store and calling an optional callback if required. Example usage:</p>
return me.callParent([options]);
},
-<span id='Ext-data.Store-method-onProxyLoad'> /**
+<span id='Ext-data-Store-method-onProxyLoad'> /**
</span> * @private
* Called internally when a Proxy has completed a load request
*/
Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
},
-<span id='Ext-data.Store-method-onCreateRecords'> /**
+<span id='Ext-data-Store-method-onCreateRecords'> /**
</span> * Create any new records when a write is returned from the server.
* @private
* @param {Array} records The array of new records
original,
index;
-<span id='Ext-data.Store-property-'> /**
-</span> * Loop over each record returned from the server. Assume they are
+ /*
+ * Loop over each record returned from the server. Assume they are
* returned in order of how they were sent. If we find a matching
* record, replace it with the newly created one.
*/
}
},
-<span id='Ext-data.Store-method-onUpdateRecords'> /**
+<span id='Ext-data-Store-method-onUpdateRecords'> /**
</span> * Update any records when a write is returned from the server.
* @private
* @param {Array} records The array of updated records
}
},
-<span id='Ext-data.Store-method-onDestroyRecords'> /**
+<span id='Ext-data-Store-method-onDestroyRecords'> /**
</span> * Remove any records when a write is returned from the server.
* @private
* @param {Array} records The array of removed records
return this.data.filterBy(this.filterUpdated).items;
},
-<span id='Ext-data.Store-method-filter'> /**
+<span id='Ext-data-Store-method-filter'> /**
</span> * Filters the loaded set of records by a given set of filters.
* @param {Mixed} filters The set of filters to apply to the data. These are stored internally on the store,
* but the filtering itself is done on the Store's {@link Ext.util.MixedCollection MixedCollection}. See
//the load function will pick up the new filters and request the filtered data from the proxy
me.load();
} else {
-<span id='Ext-data.Store-property-snapshot'> /**
+<span id='Ext-data-Store-property-snapshot'> /**
</span> * A pristine (unfiltered) collection of the records in this store. This is used to reinstate
* records when a filter is removed or changed
* @property snapshot
}
},
-<span id='Ext-data.Store-method-clearFilter'> /**
+<span id='Ext-data-Store-method-clearFilter'> /**
</span> * Revert to a view of the Record cache with no filtering applied.
* @param {Boolean} suppressEvent If <tt>true</tt> the filter is cleared silently without firing the
* {@link #datachanged} event.
}
},
-<span id='Ext-data.Store-method-isFiltered'> /**
+<span id='Ext-data-Store-method-isFiltered'> /**
</span> * Returns true if this store is currently filtered
* @return {Boolean}
*/
return !! snapshot && snapshot !== this.data;
},
-<span id='Ext-data.Store-method-filterBy'> /**
+<span id='Ext-data-Store-method-filterBy'> /**
</span> * Filter by a function. The specified function will be called for each
* Record in this Store. If the function returns <tt>true</tt> the Record is included,
* otherwise it is filtered out.
me.fireEvent('datachanged', me);
},
-<span id='Ext-data.Store-method-queryBy'> /**
+<span id='Ext-data-Store-method-queryBy'> /**
</span> * Query the cached records in this Store using a filtering function. The specified function
* will be called with each record in this Store. If the function returns <tt>true</tt> the record is
* included in the results.
return data.filterBy(fn, scope || me);
},
-<span id='Ext-data.Store-method-loadData'> /**
+<span id='Ext-data-Store-method-loadData'> /**
</span> * Loads an array of data straight into the Store
* @param {Array} data Array of data to load. Any non-model instances will be cast into model instances first
* @param {Boolean} append True to add the records to the existing records in the store, false to remove the old ones first
this.loadRecords(data, {addRecords: append});
},
-<span id='Ext-data.Store-method-loadRecords'> /**
+<span id='Ext-data-Store-method-loadRecords'> /**
</span> * Loads an array of {@Ext.data.Model model} instances into the store, fires the datachanged event. This should only usually
* be called internally when loading from the {@link Ext.data.proxy.Proxy Proxy}, when adding records manually use {@link #add} instead
* @param {Array} records The array of records to load
if (!options.addRecords) {
delete me.snapshot;
- me.data.clear();
+ me.clearData();
}
me.data.addAll(records);
},
// PAGING METHODS
-<span id='Ext-data.Store-method-loadPage'> /**
+<span id='Ext-data-Store-method-loadPage'> /**
</span> * Loads a given 'page' of data by setting the start and limit values appropriately. Internally this just causes a normal
* load operation, passing in calculated 'start' and 'limit' params
* @param {Number} page The number of the page to load
});
},
-<span id='Ext-data.Store-method-nextPage'> /**
+<span id='Ext-data-Store-method-nextPage'> /**
</span> * Loads the next 'page' in the current data set
*/
nextPage: function() {
this.loadPage(this.currentPage + 1);
},
-<span id='Ext-data.Store-method-previousPage'> /**
+<span id='Ext-data-Store-method-previousPage'> /**
</span> * Loads the previous 'page' in the current data set
*/
previousPage: function() {
},
// Buffering
-<span id='Ext-data.Store-method-prefetch'> /**
+<span id='Ext-data-Store-method-prefetch'> /**
</span> * Prefetches data the Store using its configured {@link #proxy}.
* @param {Object} options Optional config object, passed into the Ext.data.Operation object before loading.
* See {@link #load}
return me;
},
-<span id='Ext-data.Store-method-prefetchPage'> /**
+<span id='Ext-data-Store-method-prefetchPage'> /**
</span> * Prefetches a page of data.
* @param {Number} page The page to prefetch
* @param {Object} options Optional config object, passed into the Ext.data.Operation object before loading.
},
-<span id='Ext-data.Store-method-getRequestId'> /**
+<span id='Ext-data-Store-method-getRequestId'> /**
</span> * Returns a unique requestId to track requests.
* @private
*/
return this.requestSeed++;
},
-<span id='Ext-data.Store-method-onProxyPrefetch'> /**
+<span id='Ext-data-Store-method-onProxyPrefetch'> /**
</span> * Handles a success pre-fetch
* @private
* @param {Ext.data.Operation} operation The operation that completed
Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
},
-<span id='Ext-data.Store-method-cacheRecords'> /**
+<span id='Ext-data-Store-method-cacheRecords'> /**
</span> * Caches the records in the prefetch and stripes them with their server-side
* index.
* @private
},
-<span id='Ext-data.Store-method-purgeRecords'> /**
+<span id='Ext-data-Store-method-purgeRecords'> /**
</span> * Purge the least recently used records in the prefetch if the purgeCount
* has been exceeded.
*/
}
},
-<span id='Ext-data.Store-method-rangeSatisfied'> /**
+<span id='Ext-data-Store-method-rangeSatisfied'> /**
</span> * Determines if the range has already been satisfied in the prefetchData.
* @private
* @param {Number} start The start index
return satisfied;
},
-<span id='Ext-data.Store-method-getPageFromRecordIndex'> /**
+<span id='Ext-data-Store-method-getPageFromRecordIndex'> /**
</span> * Determines the page from a record index
* @param {Number} index The record index
* @return {Number} The page the record belongs to
return Math.floor(index / this.pageSize) + 1;
},
-<span id='Ext-data.Store-method-onGuaranteedRange'> /**
+<span id='Ext-data-Store-method-onGuaranteedRange'> /**
</span> * Handles a guaranteed range being loaded
* @private
*/
}
},
-<span id='Ext-data.Store-method-hasPendingRequests'> /**
+<span id='Ext-data-Store-method-hasPendingRequests'> /**
</span> * Returns the number of pending requests out.
*/
hasPendingRequests: function() {
}
},
-<span id='Ext-data.Store-method-guaranteeRange'> /**
+<span id='Ext-data-Store-method-guaranteeRange'> /**
</span> * Guarantee a specific range, this will load the store with a range (that
* must be the pageSize or smaller) and take care of any loading that may
* be necessary.
sorters = me.getSorters();
start = me.guaranteedStart;
end = me.guaranteedEnd;
- range;
if (sorters.length) {
prefetchData.sort(sorters);
}
},
-<span id='Ext-data.Store-method-find'> /**
+<span id='Ext-data-Store-method-find'> /**
</span> * Finds the index of the first matching Record in this store by a specific field value.
* @param {String} fieldName The name of the Record field to test.
* @param {String/RegExp} value Either a string that the field value
return fn ? this.data.findIndexBy(fn, null, start) : -1;
},
-<span id='Ext-data.Store-method-findRecord'> /**
+<span id='Ext-data-Store-method-findRecord'> /**
</span> * Finds the first matching Record in this store by a specific field value.
* @param {String} fieldName The name of the Record field to test.
* @param {String/RegExp} value Either a string that the field value
return index !== -1 ? me.getAt(index) : null;
},
-<span id='Ext-data.Store-method-createFilterFn'> /**
+<span id='Ext-data-Store-method-createFilterFn'> /**
</span> * @private
* Returns a filter function used to test a the given property's value. Defers most of the work to
* Ext.util.MixedCollection's createValueMatcher function
};
},
-<span id='Ext-data.Store-method-findExact'> /**
+<span id='Ext-data-Store-method-findExact'> /**
</span> * Finds the index of the first matching Record in this store by a specific field value.
* @param {String} fieldName The name of the Record field to test.
* @param {Mixed} value The value to match the field against.
this, start);
},
-<span id='Ext-data.Store-method-findBy'> /**
+<span id='Ext-data-Store-method-findBy'> /**
</span> * Find the index of the first matching Record in this Store by a function.
* If the function returns <tt>true</tt> it is considered a match.
* @param {Function} fn The function to be called. It will be passed the following parameters:<ul>
return this.data.findIndexBy(fn, scope, start);
},
-<span id='Ext-data.Store-method-collect'> /**
+<span id='Ext-data-Store-method-collect'> /**
</span> * Collects unique values for a particular dataIndex from this store.
* @param {String} dataIndex The property to collect
* @param {Boolean} allowNull (optional) Pass true to allow null, undefined or empty string values
return data.collect(dataIndex, 'data', allowNull);
},
-<span id='Ext-data.Store-method-getCount'> /**
+<span id='Ext-data-Store-method-getCount'> /**
</span> * Gets the number of cached records.
* <p>If using paging, this may not be the total size of the dataset. If the data object
* used by the Reader contains the dataset size, then the {@link #getTotalCount} function returns
return this.data.length || 0;
},
-<span id='Ext-data.Store-method-getTotalCount'> /**
+<span id='Ext-data-Store-method-getTotalCount'> /**
</span> * Returns the total number of {@link Ext.data.Model Model} instances that the {@link Ext.data.proxy.Proxy Proxy}
* indicates exist. This will usually differ from {@link #getCount} when using paging - getCount returns the
* number of records loaded into the Store at the moment, getTotalCount returns the number of records that
return this.totalCount;
},
-<span id='Ext-data.Store-method-getAt'> /**
+<span id='Ext-data-Store-method-getAt'> /**
</span> * Get the Record at the specified index.
* @param {Number} index The index of the Record to find.
* @return {Ext.data.Model} The Record at the passed index. Returns undefined if not found.
return this.data.getAt(index);
},
-<span id='Ext-data.Store-method-getRange'> /**
+<span id='Ext-data-Store-method-getRange'> /**
</span> * Returns a range of Records between specified indices.
* @param {Number} startIndex (optional) The starting index (defaults to 0)
* @param {Number} endIndex (optional) The ending index (defaults to the last Record in the Store)
return this.data.getRange(start, end);
},
-<span id='Ext-data.Store-method-getById'> /**
+<span id='Ext-data-Store-method-getById'> /**
</span> * Get the Record with the specified id.
* @param {String} id The id of the Record to find.
* @return {Ext.data.Model} The Record with the passed id. Returns undefined if not found.
});
},
-<span id='Ext-data.Store-method-indexOf'> /**
+<span id='Ext-data-Store-method-indexOf'> /**
</span> * Get the index within the cache of the passed Record.
* @param {Ext.data.Model} record The Ext.data.Model object to find.
* @return {Number} The index of the passed Record. Returns -1 if not found.
},
-<span id='Ext-data.Store-method-indexOfTotal'> /**
+<span id='Ext-data-Store-method-indexOfTotal'> /**
</span> * Get the index within the entire dataset. From 0 to the totalCount.
* @param {Ext.data.Model} record The Ext.data.Model object to find.
* @return {Number} The index of the passed Record. Returns -1 if not found.
return record.index || this.indexOf(record);
},
-<span id='Ext-data.Store-method-indexOfId'> /**
+<span id='Ext-data-Store-method-indexOfId'> /**
</span> * Get the index within the cache of the Record with the passed id.
* @param {String} id The id of the Record to find.
* @return {Number} The index of the Record. Returns -1 if not found.
return this.data.indexOfKey(id);
},
-<span id='Ext-data.Store-method-removeAll'> /**
+<span id='Ext-data-Store-method-removeAll'> /**
</span> * Remove all items from the store.
* @param {Boolean} silent Prevent the `clear` event from being fired.
*/
* Aggregation methods
*/
-<span id='Ext-data.Store-method-first'> /**
+<span id='Ext-data-Store-method-first'> /**
</span> * Convenience function for getting the first model instance in the store
* @param {Boolean} grouped (Optional) True to perform the operation for each group
* in the store. The value returned will be an object literal with the key being the group
}
},
-<span id='Ext-data.Store-method-last'> /**
+<span id='Ext-data-Store-method-last'> /**
</span> * Convenience function for getting the last model instance in the store
* @param {Boolean} grouped (Optional) True to perform the operation for each group
* in the store. The value returned will be an object literal with the key being the group
}
},
-<span id='Ext-data.Store-method-sum'> /**
+<span id='Ext-data-Store-method-sum'> /**
</span> * Sums the value of <tt>property</tt> for each {@link Ext.data.Model record} between <tt>start</tt>
* and <tt>end</tt> and returns the result.
* @param {String} field A field in each record
return total;
},
-<span id='Ext-data.Store-method-count'> /**
+<span id='Ext-data-Store-method-count'> /**
</span> * Gets the count of items in the store.
* @param {Boolean} grouped (Optional) True to perform the operation for each group
* in the store. The value returned will be an object literal with the key being the group
}
},
-<span id='Ext-data.Store-method-min'> /**
+<span id='Ext-data-Store-method-min'> /**
</span> * Gets the minimum value in the store.
* @param {String} field The field in each record
* @param {Boolean} grouped (Optional) True to perform the operation for each group
return min;
},
-<span id='Ext-data.Store-method-max'> /**
+<span id='Ext-data-Store-method-max'> /**
</span> * Gets the maximum value in the store.
* @param {String} field The field in each record
* @param {Boolean} grouped (Optional) True to perform the operation for each group
return max;
},
-<span id='Ext-data.Store-method-average'> /**
+<span id='Ext-data-Store-method-average'> /**
</span> * Gets the average value in the store.
* @param {String} field The field in each record
* @param {Boolean} grouped (Optional) True to perform the operation for each group
return 0;
},
-<span id='Ext-data.Store-method-aggregate'> /**
+<span id='Ext-data-Store-method-aggregate'> /**
</span> * Runs the aggregate function for all the records in the store.
* @param {Function} fn The function to execute. The function is called with a single parameter,
* an array of records for that group.
}
}
});
-</pre></pre></body></html>
\ No newline at end of file
+</pre>
+</body>
+</html>
git.ithinksw.org / extjs.git / blobdiff