<!DOCTYPE html>
|
<html>
|
<head>
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
<title>The source code</title>
|
<link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
|
<script type="text/javascript" src="../resources/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-AbstractStore'>/**
|
</span> * @author Ed Spencer
|
*
|
* AbstractStore is a superclass of {@link Ext.data.Store} and {@link Ext.data.TreeStore}. It's never used directly,
|
* but offers a set of methods used by both of those subclasses.
|
*
|
* We've left it here in the docs for reference purposes, but unless you need to make a whole new type of Store, what
|
* you're probably looking for is {@link Ext.data.Store}. If you're still interested, here's a brief description of what
|
* AbstractStore is and is not.
|
*
|
* AbstractStore provides the basic configuration for anything that can be considered a Store. It expects to be
|
* given a {@link Ext.data.Model Model} that represents the type of data in the Store. It also expects to be given a
|
* {@link Ext.data.proxy.Proxy Proxy} that handles the loading of data into the Store.
|
*
|
* AbstractStore provides a few helpful methods such as {@link #method-load} and {@link #sync}, which load and save data
|
* respectively, passing the requests through the configured {@link #proxy}. Both built-in Store subclasses add extra
|
* behavior to each of these functions. Note also that each AbstractStore subclass has its own way of storing data -
|
* in {@link Ext.data.Store} the data is saved as a flat {@link Ext.util.MixedCollection MixedCollection}, whereas in
|
* {@link Ext.data.TreeStore TreeStore} we use a {@link Ext.data.Tree} to maintain the data's hierarchy.
|
*
|
* The store provides filtering and sorting support. This sorting/filtering can happen on the client side
|
* or can be completed on the server. This is controlled by the {@link Ext.data.Store#remoteSort remoteSort} and
|
* {@link Ext.data.Store#remoteFilter remoteFilter} config options. For more information see the {@link #sort} and
|
* {@link Ext.data.Store#filter filter} methods.
|
*/
|
Ext.define('Ext.data.AbstractStore', {
|
requires: [
|
'Ext.util.MixedCollection',
|
'Ext.data.proxy.Proxy',
|
'Ext.data.Operation',
|
'Ext.util.Filter'
|
],
|
|
mixins: {
|
observable: 'Ext.util.Observable',
|
sortable: 'Ext.util.Sortable'
|
},
|
|
statics: {
|
<span id='Ext-data-AbstractStore-static-method-create'> /**
|
</span> * Creates a store from config object.
|
*
|
* @param {Object/Ext.data.AbstractStore} store A config for
|
* the store to be created. It may contain a `type` field
|
* which defines the particular type of store to create.
|
*
|
* Alteratively passing an actual store to this method will
|
* just return it, no changes made.
|
*
|
* @return {Ext.data.AbstractStore} The created store.
|
* @static
|
*/
|
create: function(store) {
|
if (!store.isStore) {
|
if (!store.type) {
|
store.type = 'store';
|
}
|
store = Ext.createByAlias('store.' + store.type, store);
|
}
|
return store;
|
}
|
},
|
|
<span id='Ext-data-AbstractStore-method-onClassExtended'> onClassExtended: function(cls, data, hooks) {
|
</span> var model = data.model,
|
onBeforeClassCreated;
|
|
if (typeof model == 'string') {
|
onBeforeClassCreated = hooks.onBeforeCreated;
|
|
hooks.onBeforeCreated = function() {
|
var me = this,
|
args = arguments;
|
|
Ext.require(model, function() {
|
onBeforeClassCreated.apply(me, args);
|
});
|
};
|
}
|
},
|
|
<span id='Ext-data-AbstractStore-cfg-remoteSort'> /**
|
</span> * @cfg {Boolean} remoteSort
|
* True to defer any sorting operation to the server. If false, sorting is done locally on the client.
|
*/
|
remoteSort : false,
|
|
<span id='Ext-data-AbstractStore-cfg-remoteFilter'> /**
|
</span> * @cfg {Boolean} remoteFilter
|
* True to defer any filtering operation to the server. If false, filtering is done locally on the client.
|
*/
|
remoteFilter: false,
|
|
<span id='Ext-data-AbstractStore-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.
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-data-AbstractStore-cfg-autoLoad'> /**
|
</span> * @cfg {Boolean/Object} autoLoad
|
* If data is not specified, and if autoLoad is true or an Object, this store's load method is automatically called
|
* after creation. If the value of autoLoad is an Object, this Object will be passed to the store's load method.
|
* @since 2.3.0
|
*/
|
autoLoad: undefined,
|
|
<span id='Ext-data-AbstractStore-cfg-autoSync'> /**
|
</span> * @cfg {Boolean} autoSync
|
* True to automatically sync the Store with its Proxy after every edit to one of its Records. Defaults to false.
|
*/
|
autoSync: false,
|
|
<span id='Ext-data-AbstractStore-cfg-batchUpdateMode'> /**
|
</span> * @cfg {String} batchUpdateMode
|
* Sets the updating behavior based on batch synchronization. 'operation' (the default) will update the Store's
|
* internal representation of the data after each operation of the batch has completed, 'complete' will wait until
|
* the entire batch has been completed before updating the Store's data. 'complete' is a good choice for local
|
* storage proxies, 'operation' is better for remote proxies, where there is a comparatively high latency.
|
*/
|
batchUpdateMode: 'operation',
|
|
<span id='Ext-data-AbstractStore-cfg-filterOnLoad'> /**
|
</span> * @cfg {Boolean} filterOnLoad
|
* If true, any filters attached to this Store will be run after loading data, before the datachanged event is fired.
|
* Defaults to true, ignored if {@link Ext.data.Store#remoteFilter remoteFilter} is true
|
*/
|
filterOnLoad: true,
|
|
<span id='Ext-data-AbstractStore-cfg-sortOnLoad'> /**
|
</span> * @cfg {Boolean} sortOnLoad
|
* If true, any sorters attached to this Store will be run after loading data, before the datachanged event is fired.
|
* Defaults to true, igored if {@link Ext.data.Store#remoteSort remoteSort} is true
|
*/
|
sortOnLoad: true,
|
|
<span id='Ext-data-AbstractStore-property-implicitModel'> /**
|
</span> * @property {Boolean} implicitModel
|
* True if a model was created implicitly for this Store. This happens if a fields array is passed to the Store's
|
* constructor instead of a model constructor or name.
|
* @private
|
*/
|
implicitModel: false,
|
|
<span id='Ext-data-AbstractStore-property-defaultProxyType'> /**
|
</span> * @property {String} defaultProxyType
|
* The string type of the Proxy to create if none is specified. This defaults to creating a
|
* {@link Ext.data.proxy.Memory memory proxy}.
|
*/
|
defaultProxyType: 'memory',
|
|
<span id='Ext-data-AbstractStore-property-isDestroyed'> /**
|
</span> * @property {Boolean} isDestroyed
|
* True if the Store has already been destroyed. If this is true, the reference to Store should be deleted
|
* as it will not function correctly any more.
|
* @since 3.4.0
|
*/
|
isDestroyed: false,
|
|
<span id='Ext-data-AbstractStore-property-isStore'> /**
|
</span> * @property {Boolean} isStore
|
* `true` in this class to identify an object as an instantiated Store, or subclass thereof.
|
*/
|
isStore: true,
|
|
<span id='Ext-data-AbstractStore-cfg-storeId'> /**
|
</span> * @cfg {String} storeId
|
* Unique identifier for this store. If present, this Store will be registered with the {@link Ext.data.StoreManager},
|
* making it easy to reuse elsewhere.
|
*
|
* Note that when store is instatiated by Controller, the storeId will be overridden by the name of the store.
|
*/
|
|
<span id='Ext-data-AbstractStore-cfg-fields'> /**
|
</span> * @cfg {Object[]} fields
|
* This may be used in place of specifying a {@link #model} configuration. The fields should be a
|
* set of {@link Ext.data.Field} configuration objects. The store will automatically create a {@link Ext.data.Model}
|
* with these fields. In general this configuration option should only be used for simple stores like
|
* a two-field store of ComboBox. For anything more complicated, such as specifying a particular id property or
|
* associations, a {@link Ext.data.Model} should be defined and specified for the {@link #model}
|
* config.
|
* @since 2.3.0
|
*/
|
|
<span id='Ext-data-AbstractStore-cfg-model'> /**
|
</span> * @cfg {String} model
|
* Name of the {@link Ext.data.Model Model} associated with this store.
|
* The string is used as an argument for {@link Ext.ModelManager#getModel}.
|
*/
|
|
<span id='Ext-data-AbstractStore-cfg-filters'> /**
|
</span> * @cfg {Object[]/Function[]} filters
|
* Array of {@link Ext.util.Filter Filters} for this store. Can also be passed array of
|
* functions which will be used as the {@link Ext.util.Filter#filterFn filterFn} config
|
* for filters:
|
*
|
* filters: [
|
* function(item) {
|
* return item.weight > 0;
|
* }
|
* ]
|
*
|
* To filter after the grid is loaded use the {@link Ext.data.Store#filterBy filterBy} function.
|
*/
|
|
<span id='Ext-data-AbstractStore-cfg-statefulFilters'> /**
|
</span> * @cfg {Boolean} [statefulFilters=false]
|
* Configure as `true` to have the filters saved when a client {@link Ext.grid.Panel grid} saves its state.
|
*/
|
|
sortRoot: 'data',
|
|
<span id='Ext-data-AbstractStore-method-constructor'> //documented above
|
</span> constructor: function(config) {
|
var me = this,
|
filters;
|
|
<span id='Ext-data-AbstractStore-event-add'> /**
|
</span> * @event add
|
* Fired when a Model instance has been added to this Store.
|
* @param {Ext.data.Store} store The store
|
* @param {Ext.data.Model[]} records The Model instances that were added
|
* @param {Number} index The index at which the instances were inserted
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-data-AbstractStore-event-remove'> /**
|
</span> * @event remove
|
* Fired when a Model instance has been removed from this Store.
|
*
|
* **If many records may be removed in one go, then it is more efficient to listen for the {@link #event-bulkremove} event
|
* and perform any processing for a bulk remove than to listen for this {@link #event-remove} event.**
|
* @param {Ext.data.Store} store The Store object
|
* @param {Ext.data.Model} record The record that was removed
|
* @param {Number} index The index of the record that was removed
|
* @param {Boolean} isMove `true` if the child node is being removed so it can be moved to another position in this Store.
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-data-AbstractStore-event-bulkremove'> /**
|
</span> * @event bulkremove
|
* Fired at the *end* of the {@link Ext.data.Store#method-remove remove} method when all records in the passed array have been removed.
|
*
|
* If many records may be removed in one go, then it is more efficient to listen for this event
|
* and perform any processing for a bulk remove than to listen for many {@link #event-remove} events.
|
* @param {Ext.data.Store} store The Store object
|
* @param {Ext.data.Model[]} records The array of records that were removed (In the order they appear in the Store)
|
* @param {Number[]} indexes The indexes of the records that were removed
|
* @param {Boolean} isMove `true` if the child nodes are being removed so they can be moved to another position in this Store.
|
*/
|
|
<span id='Ext-data-AbstractStore-event-update'> /**
|
</span> * @event update
|
* Fires when a Model instance has been updated.
|
* @param {Ext.data.Store} this
|
* @param {Ext.data.Model} record The Model instance that was updated
|
* @param {String} operation The update operation being performed. Value may be one of:
|
*
|
* Ext.data.Model.EDIT
|
* Ext.data.Model.REJECT
|
* Ext.data.Model.COMMIT
|
* @param {String[]} modifiedFieldNames Array of field names changed during edit.
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-data-AbstractStore-event-datachanged'> /**
|
</span> * @event datachanged
|
* Fires whenever the records in the Store have changed in some way - this could include adding or removing
|
* records, or updating the data in existing records
|
* @param {Ext.data.Store} this The data store
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-data-AbstractStore-event-refresh'> /**
|
</span> * @event refresh
|
* Fires when the data cache has changed in a bulk manner (e.g., it has been sorted, filtered, etc.) and a
|
* widget that is using this Store as a Record cache should refresh its view.
|
* @param {Ext.data.Store} this The data store
|
*/
|
|
<span id='Ext-data-AbstractStore-event-beforeload'> /**
|
</span> * @event beforeload
|
* Fires before a request is made for a new data object. If the beforeload handler returns false the load
|
* action will be canceled.
|
* @param {Ext.data.Store} store This Store
|
* @param {Ext.data.Operation} operation The Ext.data.Operation object that will be passed to the Proxy to
|
* load the Store
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-data-AbstractStore-event-load'> /**
|
</span> * @event load
|
* Fires whenever the store reads data from a remote data source.
|
* @param {Ext.data.Store} this
|
* @param {Ext.data.Model[]} records An array of records
|
* @param {Boolean} successful True if the operation was successful.
|
* @since 1.1.0
|
*/
|
|
<span id='Ext-data-AbstractStore-event-write'> /**
|
</span> * @event write
|
* Fires whenever a successful write has been made via the configured {@link #proxy Proxy}
|
* @param {Ext.data.Store} store This Store
|
* @param {Ext.data.Operation} operation The {@link Ext.data.Operation Operation} object that was used in
|
* the write
|
* @since 3.4.0
|
*/
|
|
<span id='Ext-data-AbstractStore-event-beforesync'> /**
|
</span> * @event beforesync
|
* Fired before a call to {@link #sync} is executed. Return false from any listener to cancel the sync
|
* @param {Object} options Hash of all records to be synchronized, broken down into create, update and destroy
|
*/
|
<span id='Ext-data-AbstractStore-event-clear'> /**
|
</span> * @event clear
|
* Fired after the {@link #removeAll} method is called.
|
* @param {Ext.data.Store} this
|
* @since 1.1.0
|
*/
|
<span id='Ext-data-AbstractStore-event-metachange'> /**
|
</span> * @event metachange
|
* Fires when this store's underlying reader (available via the proxy) provides new metadata.
|
* Metadata usually consists of new field definitions, but can include any configuration data
|
* required by an application, and can be processed as needed in the event handler.
|
* This event is currently only fired for JsonReaders.
|
* @param {Ext.data.Store} this
|
* @param {Object} meta The JSON metadata
|
* @since 1.1.0
|
*/
|
|
Ext.apply(me, config);
|
// don't use *config* anymore from here on... use *me* instead...
|
|
<span id='Ext-data-AbstractStore-property-removed'> /**
|
</span> * Temporary cache in which removed model instances are kept until successfully synchronised with a Proxy,
|
* at which point this is cleared.
|
* @protected
|
* @property {Ext.data.Model[]} removed
|
*/
|
me.removed = [];
|
|
me.mixins.observable.constructor.apply(me, arguments);
|
|
// <debug>
|
var configModel = me.model;
|
// </debug>
|
|
me.model = Ext.ModelManager.getModel(me.model);
|
|
<span id='Ext-data-AbstractStore-property-modelDefaults'> /**
|
</span> * @property {Object} modelDefaults
|
* @private
|
* A set of default values to be applied to every model instance added via {@link Ext.data.Store#insert insert} or created
|
* via {@link Ext.data.Store#createModel createModel}. This is used internally by associations to set foreign keys and
|
* other fields. See the Association classes source code for examples. This should not need to be used by application developers.
|
*/
|
Ext.applyIf(me, {
|
modelDefaults: null
|
});
|
|
//Supports the 3.x style of simply passing an array of fields to the store, implicitly creating a model
|
if (!me.model && me.fields) {
|
me.model = Ext.define('Ext.data.Store.ImplicitModel-' + (me.storeId || Ext.id()), {
|
extend: 'Ext.data.Model',
|
fields: me.fields,
|
proxy: me.proxy || me.defaultProxyType
|
});
|
|
delete me.fields;
|
|
me.implicitModel = true;
|
}
|
|
// <debug>
|
if (!me.model && me.useModelWarning !== false) {
|
// There are a number of ways things could have gone wrong, try to give as much information as possible
|
var logMsg = [
|
Ext.getClassName(me) || 'Store',
|
' created with no model.'
|
];
|
|
if (typeof configModel === 'string') {
|
logMsg.push(" The name '", configModel, "'", ' does not correspond to a valid model.');
|
}
|
|
Ext.log.warn(logMsg.join(''));
|
}
|
// </debug>
|
|
//ensures that the Proxy is instantiated correctly
|
me.setProxy(me.proxy || me.model.getProxy());
|
|
if (!me.disableMetaChangeEvent) {
|
me.proxy.on('metachange', me.onMetaChange, me);
|
}
|
|
if (me.id && !me.storeId) {
|
me.storeId = me.id;
|
delete me.id;
|
}
|
|
if (me.storeId) {
|
Ext.data.StoreManager.register(me);
|
}
|
|
me.mixins.sortable.initSortable.call(me);
|
|
<span id='Ext-data-AbstractStore-property-filters'> /**
|
</span> * @property {Ext.util.MixedCollection} filters
|
* The collection of {@link Ext.util.Filter Filters} currently applied to this Store
|
*/
|
filters = me.decodeFilters(me.filters);
|
me.filters = new Ext.util.MixedCollection();
|
me.filters.addAll(filters);
|
},
|
|
<span id='Ext-data-AbstractStore-method-setProxy'> /**
|
</span> * Sets the Store's Proxy by string, config object or Proxy instance
|
* @param {String/Object/Ext.data.proxy.Proxy} proxy The new Proxy, which can be either a type string, a configuration object
|
* or an Ext.data.proxy.Proxy instance
|
* @return {Ext.data.proxy.Proxy} The attached Proxy object
|
*/
|
setProxy: function(proxy) {
|
var me = this;
|
|
if (proxy instanceof Ext.data.proxy.Proxy) {
|
proxy.setModel(me.model);
|
} else {
|
if (Ext.isString(proxy)) {
|
proxy = {
|
type: proxy
|
};
|
}
|
Ext.applyIf(proxy, {
|
model: me.model
|
});
|
|
proxy = Ext.createByAlias('proxy.' + proxy.type, proxy);
|
}
|
|
me.proxy = proxy;
|
|
return me.proxy;
|
},
|
|
<span id='Ext-data-AbstractStore-method-getProxy'> /**
|
</span> * Returns the proxy currently attached to this proxy instance
|
* @return {Ext.data.proxy.Proxy} The Proxy instance
|
*/
|
getProxy: function() {
|
return this.proxy;
|
},
|
|
<span id='Ext-data-AbstractStore-method-onMetaChange'> // private
|
</span> onMetaChange: function(proxy, meta) {
|
this.fireEvent('metachange', this, meta);
|
},
|
|
<span id='Ext-data-AbstractStore-method-create'> //saves any phantom records
|
</span> create: function(data, options) {
|
var me = this,
|
instance = Ext.ModelManager.create(Ext.applyIf(data, me.modelDefaults), me.model.modelName),
|
operation;
|
|
options = options || {};
|
|
Ext.applyIf(options, {
|
action : 'create',
|
records: [instance]
|
});
|
|
operation = new Ext.data.Operation(options);
|
|
me.proxy.create(operation, me.onProxyWrite, me);
|
|
return instance;
|
},
|
|
<span id='Ext-data-AbstractStore-method-read'> read: function() {
|
</span> return this.load.apply(this, arguments);
|
},
|
|
<span id='Ext-data-AbstractStore-method-update'> update: function(options) {
|
</span> var me = this,
|
operation;
|
options = options || {};
|
|
Ext.applyIf(options, {
|
action : 'update',
|
records: me.getUpdatedRecords()
|
});
|
|
operation = new Ext.data.Operation(options);
|
|
return me.proxy.update(operation, me.onProxyWrite, me);
|
},
|
|
<span id='Ext-data-AbstractStore-method-onProxyWrite'> /**
|
</span> * @private
|
* Callback for any write Operation over the Proxy. Updates the Store's MixedCollection to reflect
|
* the updates provided by the Proxy
|
*/
|
onProxyWrite: function(operation) {
|
var me = this,
|
success = operation.wasSuccessful(),
|
records = operation.getRecords();
|
|
switch (operation.action) {
|
case 'create':
|
me.onCreateRecords(records, operation, success);
|
break;
|
case 'update':
|
me.onUpdateRecords(records, operation, success);
|
break;
|
case 'destroy':
|
me.onDestroyRecords(records, operation, success);
|
break;
|
}
|
|
if (success) {
|
me.fireEvent('write', me, operation);
|
me.fireEvent('datachanged', me);
|
me.fireEvent('refresh', me);
|
}
|
//this is a callback that would have been passed to the 'create', 'update' or 'destroy' function and is optional
|
Ext.callback(operation.callback, operation.scope || me, [records, operation, success]);
|
},
|
|
<span id='Ext-data-AbstractStore-method-onCreateRecords'> // may be implemented by store subclasses
|
</span> onCreateRecords: Ext.emptyFn,
|
|
<span id='Ext-data-AbstractStore-method-onUpdateRecords'> // may be implemented by store subclasses
|
</span> onUpdateRecords: Ext.emptyFn,
|
|
<span id='Ext-data-AbstractStore-method-onDestroyRecords'> /**
|
</span> * Removes any records when a write is returned from the server.
|
* @private
|
* @param {Ext.data.Model[]} records The array of removed records
|
* @param {Ext.data.Operation} operation The operation that just completed
|
* @param {Boolean} success True if the operation was successful
|
*/
|
onDestroyRecords: function(records, operation, success) {
|
if (success) {
|
this.removed = [];
|
}
|
},
|
|
<span id='Ext-data-AbstractStore-method-destroy'> // tells the attached proxy to destroy the given records
|
</span> // @since 3.4.0
|
destroy: function(options) {
|
var me = this,
|
operation;
|
|
options = options || {};
|
|
Ext.applyIf(options, {
|
action : 'destroy',
|
records: me.getRemovedRecords()
|
});
|
|
operation = new Ext.data.Operation(options);
|
|
return me.proxy.destroy(operation, me.onProxyWrite, me);
|
},
|
|
<span id='Ext-data-AbstractStore-method-onBatchOperationComplete'> /**
|
</span> * @private
|
* Attached as the 'operationcomplete' event listener to a proxy's Batch object. By default just calls through
|
* to onProxyWrite.
|
*/
|
onBatchOperationComplete: function(batch, operation) {
|
return this.onProxyWrite(operation);
|
},
|
|
<span id='Ext-data-AbstractStore-method-onBatchComplete'> /**
|
</span> * @private
|
* Attached as the 'complete' event listener to a proxy's Batch object. Iterates over the batch operations
|
* and updates the Store's internal data MixedCollection.
|
*/
|
onBatchComplete: function(batch, operation) {
|
var me = this,
|
operations = batch.operations,
|
length = operations.length,
|
i;
|
|
me.suspendEvents();
|
|
for (i = 0; i < length; i++) {
|
me.onProxyWrite(operations[i]);
|
}
|
|
me.resumeEvents();
|
|
me.fireEvent('datachanged', me);
|
me.fireEvent('refresh', me);
|
},
|
|
<span id='Ext-data-AbstractStore-method-onBatchException'> /**
|
</span> * @private
|
*/
|
onBatchException: function(batch, operation) {
|
// //decide what to do... could continue with the next operation
|
// batch.start();
|
//
|
// //or retry the last operation
|
// batch.retry();
|
},
|
|
<span id='Ext-data-AbstractStore-method-filterNew'> /**
|
</span> * @private
|
* Filter function for new records.
|
*/
|
filterNew: function(item) {
|
// only want phantom records that are valid
|
return item.phantom === true && item.isValid();
|
},
|
|
<span id='Ext-data-AbstractStore-method-getNewRecords'> /**
|
</span> * Returns all Model instances that are either currently a phantom (e.g. have no id), or have an ID but have not
|
* yet been saved on this Store (this happens when adding a non-phantom record from another Store into this one)
|
* @return {Ext.data.Model[]} The Model instances
|
*/
|
getNewRecords: function() {
|
return [];
|
},
|
|
<span id='Ext-data-AbstractStore-method-getUpdatedRecords'> /**
|
</span> * Returns all Model instances that have been updated in the Store but not yet synchronized with the Proxy
|
* @return {Ext.data.Model[]} The updated Model instances
|
*/
|
getUpdatedRecords: function() {
|
return [];
|
},
|
|
<span id='Ext-data-AbstractStore-method-getModifiedRecords'> /**
|
</span> * Gets all {@link Ext.data.Model records} added or updated since the last commit. Note that the order of records
|
* returned is not deterministic and does not indicate the order in which records were modified. Note also that
|
* removed records are not included (use {@link #getRemovedRecords} for that).
|
* @return {Ext.data.Model[]} The added and updated Model instances
|
*/
|
getModifiedRecords : function(){
|
return [].concat(this.getNewRecords(), this.getUpdatedRecords());
|
},
|
|
<span id='Ext-data-AbstractStore-method-filterUpdated'> /**
|
</span> * @private
|
* Filter function for updated records.
|
*/
|
filterUpdated: function(item) {
|
// only want dirty records, not phantoms that are valid
|
return item.dirty === true && item.phantom !== true && item.isValid();
|
},
|
|
<span id='Ext-data-AbstractStore-method-getRemovedRecords'> /**
|
</span> * Returns any records that have been removed from the store but not yet destroyed on the proxy.
|
* @return {Ext.data.Model[]} The removed Model instances
|
*/
|
getRemovedRecords: function() {
|
return this.removed;
|
},
|
|
<span id='Ext-data-AbstractStore-method-filter'> filter: function(filters, value) {
|
</span>
|
},
|
|
<span id='Ext-data-AbstractStore-method-decodeFilters'> /**
|
</span> * @private
|
* Normalizes an array of filter objects, ensuring that they are all Ext.util.Filter instances
|
* @param {Object[]} filters The filters array
|
* @return {Ext.util.Filter[]} Array of Ext.util.Filter objects
|
*/
|
decodeFilters: function(filters) {
|
if (!Ext.isArray(filters)) {
|
if (filters === undefined) {
|
filters = [];
|
} else {
|
filters = [filters];
|
}
|
}
|
|
var length = filters.length,
|
Filter = Ext.util.Filter,
|
config, i;
|
|
for (i = 0; i < length; i++) {
|
config = filters[i];
|
|
if (!(config instanceof Filter)) {
|
Ext.apply(config, {
|
root: 'data'
|
});
|
|
//support for 3.x style filters where a function can be defined as 'fn'
|
if (config.fn) {
|
config.filterFn = config.fn;
|
}
|
|
//support a function to be passed as a filter definition
|
if (typeof config == 'function') {
|
config = {
|
filterFn: config
|
};
|
}
|
|
filters[i] = new Filter(config);
|
}
|
}
|
|
return filters;
|
},
|
|
<span id='Ext-data-AbstractStore-method-clearFilter'> clearFilter: function(supressEvent) {
|
</span>
|
},
|
|
<span id='Ext-data-AbstractStore-method-isFiltered'> isFiltered: function() {
|
</span>
|
},
|
|
<span id='Ext-data-AbstractStore-method-filterBy'> filterBy: function(fn, scope) {
|
</span>
|
},
|
|
<span id='Ext-data-AbstractStore-method-sync'> /**
|
</span> * Synchronizes the store with its {@link #proxy}. This asks the proxy to batch together any new, updated
|
* and deleted records in the store, updating the store's internal representation of the records
|
* as each operation completes.
|
*
|
* @param {Object} [options] Object containing one or more properties supported by the sync method (these get
|
* passed along to the underlying proxy's {@link Ext.data.Proxy#batch batch} method):
|
*
|
* @param {Ext.data.Batch/Object} [options.batch] A {@link Ext.data.Batch} object (or batch config to apply
|
* to the created batch). If unspecified a default batch will be auto-created as needed.
|
*
|
* @param {Function} [options.callback] The function to be called upon completion of the sync.
|
* The callback is called regardless of success or failure and is passed the following parameters:
|
* @param {Ext.data.Batch} options.callback.batch The {@link Ext.data.Batch batch} that was processed,
|
* containing all operations in their current state after processing
|
* @param {Object} options.callback.options The options argument that was originally passed into sync
|
*
|
* @param {Function} [options.success] The function to be called upon successful completion of the sync. The
|
* success function is called only if no exceptions were reported in any operations. If one or more exceptions
|
* occurred then the failure function will be called instead. The success function is called
|
* with the following parameters:
|
* @param {Ext.data.Batch} options.success.batch The {@link Ext.data.Batch batch} that was processed,
|
* containing all operations in their current state after processing
|
* @param {Object} options.success.options The options argument that was originally passed into sync
|
*
|
* @param {Function} [options.failure] The function to be called upon unsuccessful completion of the sync. The
|
* failure function is called when one or more operations returns an exception during processing (even if some
|
* operations were also successful). In this case you can check the batch's {@link Ext.data.Batch#exceptions
|
* exceptions} array to see exactly which operations had exceptions. The failure function is called with the
|
* following parameters:
|
* @param {Ext.data.Batch} options.failure.batch The {@link Ext.data.Batch} that was processed, containing all
|
* operations in their current state after processing
|
* @param {Object} options.failure.options The options argument that was originally passed into sync
|
*
|
* @param {Object} [options.scope] The scope in which to execute any callbacks (i.e. the `this` object inside
|
* the callback, success and/or failure functions). Defaults to the store's proxy.
|
*
|
* @return {Ext.data.Store} this
|
*/
|
sync: function(options) {
|
var me = this,
|
operations = {},
|
toCreate = me.getNewRecords(),
|
toUpdate = me.getUpdatedRecords(),
|
toDestroy = me.getRemovedRecords(),
|
needsSync = false;
|
|
if (toCreate.length > 0) {
|
operations.create = toCreate;
|
needsSync = true;
|
}
|
|
if (toUpdate.length > 0) {
|
operations.update = toUpdate;
|
needsSync = true;
|
}
|
|
if (toDestroy.length > 0) {
|
operations.destroy = toDestroy;
|
needsSync = true;
|
}
|
|
if (needsSync && me.fireEvent('beforesync', operations) !== false) {
|
options = options || {};
|
|
me.proxy.batch(Ext.apply(options, {
|
operations: operations,
|
listeners: me.getBatchListeners()
|
}));
|
}
|
|
return me;
|
},
|
|
<span id='Ext-data-AbstractStore-method-getBatchListeners'> /**
|
</span> * @private
|
* Returns an object which is passed in as the listeners argument to proxy.batch inside this.sync.
|
* This is broken out into a separate function to allow for customisation of the listeners
|
* @return {Object} The listeners object
|
*/
|
getBatchListeners: function() {
|
var me = this,
|
listeners = {
|
scope: me,
|
exception: me.onBatchException
|
};
|
|
if (me.batchUpdateMode == 'operation') {
|
listeners.operationcomplete = me.onBatchOperationComplete;
|
} else {
|
listeners.complete = me.onBatchComplete;
|
}
|
|
return listeners;
|
},
|
|
<span id='Ext-data-AbstractStore-method-save'> /**
|
</span> * Saves all pending changes via the configured {@link #proxy}. Use {@link #sync} instead.
|
* @deprecated 4.0.0 Will be removed in the next major version
|
*/
|
save: function() {
|
return this.sync.apply(this, arguments);
|
},
|
|
<span id='Ext-data-AbstractStore-method-load'> /**
|
</span> * Loads the Store using its configured {@link #proxy}.
|
* @param {Object} options (optional) config object. This is passed into the {@link Ext.data.Operation Operation}
|
* object that is created and then sent to the proxy's {@link Ext.data.proxy.Proxy#read} function
|
*
|
* @return {Ext.data.Store} this
|
* @since 1.1.0
|
*/
|
load: function(options) {
|
var me = this,
|
operation;
|
|
options = Ext.apply({
|
action: 'read',
|
filters: me.filters.items,
|
sorters: me.getSorters()
|
}, options);
|
me.lastOptions = options;
|
|
operation = new Ext.data.Operation(options);
|
|
if (me.fireEvent('beforeload', me, operation) !== false) {
|
me.loading = true;
|
me.proxy.read(operation, me.onProxyLoad, me);
|
}
|
|
return me;
|
},
|
|
<span id='Ext-data-AbstractStore-method-reload'> /**
|
</span> * Reloads the store using the last options passed to the {@link #method-load} method.
|
* @param {Object} options A config object which contains options which may override the options passed to the previous load call.
|
*/
|
reload: function(options) {
|
return this.load(Ext.apply(this.lastOptions, options));
|
},
|
|
<span id='Ext-data-AbstractStore-method-afterEdit'> /**
|
</span> * @private
|
* A model instance should call this method on the Store it has been {@link Ext.data.Model#join joined} to.
|
* @param {Ext.data.Model} record The model instance that was edited
|
* @param {String[]} modifiedFieldNames Array of field names changed during edit.
|
* @since 3.4.0
|
*/
|
afterEdit : function(record, modifiedFieldNames) {
|
var me = this,
|
i, shouldSync;
|
|
if (me.autoSync && !me.autoSyncSuspended) {
|
for (i = modifiedFieldNames.length; i--;) {
|
// only sync if persistent fields were modified
|
if (record.fields.get(modifiedFieldNames[i]).persist) {
|
shouldSync = true;
|
break;
|
}
|
}
|
if (shouldSync) {
|
me.sync();
|
}
|
}
|
me.onUpdate(record, Ext.data.Model.EDIT, modifiedFieldNames);
|
me.fireEvent('update', me, record, Ext.data.Model.EDIT, modifiedFieldNames);
|
},
|
|
<span id='Ext-data-AbstractStore-method-afterReject'> /**
|
</span> * @private
|
* A model instance should call this method on the Store it has been {@link Ext.data.Model#join joined} to..
|
* @param {Ext.data.Model} record The model instance that was edited
|
* @since 3.4.0
|
*/
|
afterReject : function(record) {
|
// Must pass the 5th param (modifiedFieldNames) as null, otherwise the
|
// event firing machinery appends the listeners "options" object to the arg list
|
// which may get used as the modified fields array by a handler.
|
// This array is used for selective grid cell updating by Grid View.
|
// Null will be treated as though all cells need updating.
|
this.onUpdate(record, Ext.data.Model.REJECT, null);
|
this.fireEvent('update', this, record, Ext.data.Model.REJECT, null);
|
},
|
|
<span id='Ext-data-AbstractStore-method-afterCommit'> /**
|
</span> * @private
|
* A model instance should call this method on the Store it has been {@link Ext.data.Model#join joined} to.
|
* @param {Ext.data.Model} record The model instance that was edited
|
* @since 3.4.0
|
*/
|
afterCommit : function(record, modifiedFieldNames) {
|
if (!modifiedFieldNames) {
|
modifiedFieldNames = null;
|
}
|
this.onUpdate(record, Ext.data.Model.COMMIT, modifiedFieldNames);
|
this.fireEvent('update', this, record, Ext.data.Model.COMMIT, modifiedFieldNames);
|
},
|
|
<span id='Ext-data-AbstractStore-method-onUpdate'> onUpdate: Ext.emptyFn,
|
</span>
|
<span id='Ext-data-AbstractStore-method-onIdChanged'> onIdChanged: function(model, oldId, newId, oldInternalId){
|
</span> this.fireEvent('idchanged', this, model, oldId, newId, oldInternalId);
|
},
|
|
<span id='Ext-data-AbstractStore-method-destroyStore'> // private
|
</span> destroyStore: function() {
|
var implicitModelName,
|
me = this;
|
|
if (!me.isDestroyed) {
|
me.clearListeners();
|
if (me.storeId) {
|
Ext.data.StoreManager.unregister(me);
|
}
|
me.clearData();
|
me.data = me.tree = me.sorters = me.filters = me.groupers = null;
|
if (me.reader) {
|
me.reader.destroyReader();
|
}
|
me.proxy = me.reader = me.writer = null;
|
me.isDestroyed = true;
|
|
if (me.implicitModel) {
|
implicitModelName = Ext.getClassName(me.model);
|
Ext.undefine(implicitModelName);
|
Ext.ModelManager.unregisterType(implicitModelName);
|
} else {
|
me.model = null;
|
}
|
}
|
},
|
|
<span id='Ext-data-AbstractStore-method-getState'> /**
|
</span> * @private
|
* Returns the grouping, sorting and filtered state of this Store.
|
*/
|
getState: function() {
|
var me = this,
|
hasState,
|
result,
|
hasGroupers = !!me.groupers,
|
groupers = [],
|
sorters = [],
|
filters = [];
|
|
if (hasGroupers) {
|
me.groupers.each(function(g) {
|
groupers[groupers.length] = g.serialize();
|
hasState = true;
|
});
|
}
|
|
if (me.sorters) {
|
// Create sorters config array.
|
me.sorters.each(function(s) {
|
// Sorters collection gets groupers prepended to it, so do not duplicate
|
if (hasGroupers && !me.groupers.contains(s)) {
|
sorters[sorters.length] = s.serialize();
|
hasState = true;
|
}
|
});
|
}
|
|
// Because we do not provide a filter changing mechanism, only statify the filters if they opt in.
|
// Otherwise filters would get "stuck".
|
if (me.filters && me.statefulFilters) {
|
me.filters.each(function(f) {
|
filters[filters.length] = f.serialize();
|
hasState = true;
|
});
|
}
|
|
// If there is any state to save, return it as an object
|
if (hasState) {
|
result = {};
|
if (groupers.length) {
|
result.groupers = groupers;
|
}
|
if (sorters.length) {
|
result.sorters = sorters;
|
}
|
if (filters.length) {
|
result.filters = filters;
|
}
|
return result;
|
}
|
},
|
|
<span id='Ext-data-AbstractStore-method-applyState'> /**
|
</span> * @private
|
* Restores state to the passed state
|
*/
|
applyState: function(state) {
|
var me = this,
|
hasSorters = !!me.sorters,
|
hasGroupers = !!me.groupers,
|
hasFilters = !!me.filters,
|
locallySorted;
|
|
if (hasGroupers && state.groupers) {
|
me.groupers.clear();
|
me.groupers.addAll(me.decodeGroupers(state.groupers));
|
}
|
|
if (hasSorters && state.sorters) {
|
me.sorters.clear();
|
me.sorters.addAll(me.decodeSorters(state.sorters));
|
}
|
|
if (hasFilters && state.filters) {
|
me.filters.clear();
|
me.filters.addAll(me.decodeFilters(state.filters));
|
}
|
|
if (hasSorters && hasGroupers) {
|
// Sorters collection gets groupers prepended to it
|
me.sorters.insert(0, me.groupers.getRange());
|
}
|
|
// Data manipulated by the server - reload
|
if (me.autoLoad && (me.remoteSort || me.remoteGroup || me.remoteFilter)) {
|
if (me.autoLoad === true) {
|
me.reload();
|
} else {
|
me.reload(me.autoLoad);
|
}
|
}
|
|
// If we have local filters, filter the data
|
if (hasFilters && me.filters.length && !me.remoteFilter) {
|
me.filter();
|
locallySorted = me.sortOnFilter;
|
}
|
|
// If we have local sorters, and the data is not already sorted by a sortOnFilter operation, then sort.
|
if (hasSorters && me.sorters.length && !me.remoteSort && !locallySorted) {
|
me.sort();
|
}
|
},
|
|
<span id='Ext-data-AbstractStore-method-doSort'> // private
|
</span> doSort: function(sorterFn) {
|
var me = this;
|
if (me.remoteSort) {
|
//the load function will pick up the new sorters and request the sorted data from the proxy
|
me.load();
|
} else {
|
me.data.sortBy(sorterFn);
|
me.fireEvent('datachanged', me);
|
me.fireEvent('refresh', me);
|
}
|
me.fireEvent('sort', me, me.sorters.getRange());
|
},
|
|
<span id='Ext-data-AbstractStore-method-clearData'> // to be implemented by subclasses
|
</span> clearData: Ext.emptyFn,
|
|
<span id='Ext-data-AbstractStore-method-getCount'> // to be implemented by subclasses
|
</span> getCount: Ext.emptyFn,
|
|
<span id='Ext-data-AbstractStore-method-getById'> // to be implemented by subclasses
|
</span> getById: Ext.emptyFn,
|
|
<span id='Ext-data-AbstractStore-method-removeAll'> /**
|
</span> * Removes all records from the store. This method does a "fast remove",
|
* individual remove events are not called. The {@link #clear} event is
|
* fired upon completion.
|
* @method
|
* @since 1.1.0
|
*/
|
removeAll: Ext.emptyFn,
|
// individual store subclasses should implement a "fast" remove
|
// and fire a clear event afterwards
|
|
<span id='Ext-data-AbstractStore-method-isLoading'> /**
|
</span> * Returns true if the Store is currently performing a load operation
|
* @return {Boolean} True if the Store is currently loading
|
*/
|
isLoading: function() {
|
return !!this.loading;
|
},
|
|
<span id='Ext-data-AbstractStore-method-suspendAutoSync'> /**
|
</span> * Suspends automatically syncing the Store with its Proxy. Only applicable if {@link #autoSync} is `true`
|
*/
|
suspendAutoSync: function() {
|
this.autoSyncSuspended = true;
|
},
|
|
<span id='Ext-data-AbstractStore-method-resumeAutoSync'> /**
|
</span> * Resumes automatically syncing the Store with its Proxy. Only applicable if {@link #autoSync} is `true`
|
*/
|
resumeAutoSync: function() {
|
this.autoSyncSuspended = false;
|
}
|
|
});
|
</pre>
|
</body>
|
</html>
|
