# Store.js

    /**
     * @class Ext.data.Store
     * @extends Ext.util.Observable
     * The Store class encapsulates a client side cache of {@link Ext.data.Record} objects which provide input data
     * for widgets such as the Ext.grid.Grid, or the Ext.form.ComboBox.
     * A Store object uses an implementation of {@link Ext.data.DataProxy} to access a data object unless you call loadData() directly and pass in your data. The Store object
     * has no knowledge of the format of the data returned by the Proxy.
     * The Store object uses its configured implementation of Ext.data.DataReader to create Ext.data.Record
     * instances from the data object. These records are cached and made available through accessor functions.
     * @constructor
     * Creates a new Store
     * @param {Object} config A config object containing the objects needed for the Store to access data,
     * and read the data into Records.
     */
    Ext.data.Store = function(config){
        this.data = new Ext.util.MixedCollection(false);
        this.data.getKey = function(o){
            return o.id;
        };
        this.baseParams = {};
        this.paramNames = {
            "start" : "start",
            "limit" : "limit",
            "sort" : "sort",
            "dir" : "dir"
        };
        Ext.apply(this, config);

        if(this.reader && !this.recordType){ // reader passed
            this.recordType = this.reader.recordType;
        }

        this.fields = this.recordType.prototype.fields;

        this.modified = [];

        this.addEvents({
            /**
             * @event datachanged
             * Fires when the data cache has changed, and a widget which is using this Store
             * as a Record cache should refresh its view.
             * @param {Store} this
             */
            datachanged : true,
            /**
             * @event add
             * Fires when Records have been added to the Store
             * @param {Store} this
             * @param {Ext.data.Record[]} records The array of Records added
             * @param {Number} index The index at which the record(s) were added
             */
            add : true,
            /**
             * @event remove
             * Fires when Records have been removed from the Store
             * @param {Store} this
             * @param {Ext.data.Record} record The Record that was removed
             * @param {Number} index The index at which the record was removed
             */
            remove : true,
            /**
             * @event update
             * Fires when Records have been updated
             * @param {Store} this
             * @param {Ext.data.Record} record The Record that was updated
             * @param {String} operation The update operation being performed.  Value may be one of:
             * <pre><code>
     Ext.data.Record.EDIT
     Ext.data.Record.REJECT
     Ext.data.Record.COMMIT
             * </code></pre>
             */
            update : true,
            /**
             * @event clear
             * Fires when the data cache has been cleared.
             * @param {Store} this
             */
            clear : true,
            /**
             * @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 {Store} this
             * @param {Object} options The loading options that were specified (see {@link #load} for details)
             */
            beforeload : true,
            /**
             * @event load
             * Fires after a new set of Records has been loaded.
             * @param {Store} this
             * @param {Ext.data.Record[]} records The Records that were loaded
             * @param {Object} options The loading options that were specified (see {@link #load} for details)
             */
            load : true,
            /**
             * @event loadexception
             * Fires if an exception occurs in the Proxy during loading.
             * Called with the signature of the Proxy's "loadexception" event.
             */
            loadexception : true
        });

        if(this.proxy){
            this.relayEvents(this.proxy,  ["loadexception"]);
        }
        this.sortToggle = {};

        Ext.data.Store.superclass.constructor.call(this);
    };
    Ext.extend(Ext.data.Store, Ext.util.Observable, {
        /**
        * @cfg {Ext.data.DataProxy} proxy The Proxy object which provides access to a data object.
        */
    // holder
    /***
        * @cfg {Ext.data.Reader} reader The Reader object which processes the data object and returns
        * an Array of Ext.data.record objects which are cached keyed by their <em>id</em> property.
        */
    // holder
    /***
        * @cfg {Object} baseParams An object containing properties which are to be sent as parameters
        * on any HTTP request
        */
    // holder
    /***
        * @cfg {Object} sortInfo A config object in the format: {field: "fieldName", direction: "ASC|DESC"}
        */
    // holder
    /***
        * @cfg {boolean} remoteSort True if sorting is to be handled by requesting the Proxy to provide a refreshed
        * version of the data object in sorted order, as opposed to sorting the Record cache in place (defaults to false).
        */
        remoteSort : false,

        // private
        lastOptions : null,

        /**
         * Add Records to the Store and fires the add event.
         * @param {Ext.data.Record[]} records An Array of Ext.data.Record objects to add to the cache.
         */
        add : function(records){
            records = [].concat(records);
            for(var i = 0, len = records.length; i < len; i++){
                records[i].join(this);
            }
            var index = this.data.length;
            this.data.addAll(records);
            this.fireEvent("add", this, records, index);
        },

        /**
         * Remove a Record from the Store and fires the remove event.
         * @param {Ext.data.Record} record Th Ext.data.Record object to remove from the cache.
         */
        remove : function(record){
            var index = this.data.indexOf(record);
            this.data.removeAt(index);
            this.fireEvent("remove", this, record, index);
        },

        /**
         * Remove all Records from the Store and fires the clear event.
         */
        removeAll : function(){
            this.data.clear();
            this.fireEvent("clear", this);
        },

        /**
         * Inserts Records to the Store at the given index and fires the add event.
         * @param {Number} index The start index at which to insert the passed Records.
         * @param {Ext.data.Record[]} records An Array of Ext.data.Record objects to add to the cache.
         */
        insert : function(index, records){
            records = [].concat(records);
            for(var i = 0, len = records.length; i < len; i++){
                this.data.insert(index, records[i]);
                records[i].join(this);
            }
            this.fireEvent("add", this, records, index);
        },

        /**
         * Get the index within the cache of the passed Record.
         * @param {Ext.data.Record[]} records An Array of Ext.data.Record objects to add to the cache.
         * @return {Number} The index of the passed Record. Returns -1 if not found.
         */
        indexOf : function(record){
            return this.data.indexOf(record);
        },

        /**
         * 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.
         */
        indexOfId : function(id){
            return this.data.indexOfKey(id);
        },

        /**
         * Get the Record with the specified id.
         * @param {String} id The id of the Record to find.
         * @return {Ext.data.Record} The Record with the passed id. Returns undefined if not found.
         */
        getById : function(id){
            return this.data.key(id);
        },

        /**
         * Get the Record at the specified index.
         * @param {String} index The index of the Record to find.
         * @return {Ext.data.Record} The Record at the passed index. Returns undefined if not found.
         */
        getAt : function(index){
            return this.data.itemAt(index);
        },

        /**
         * 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 {Ext.data.Record[]} An array of Records
         */
        getRange : function(start, end){
            return this.data.getRange(start, end);
        },

        // private
        storeOptions : function(o){
            o = Ext.apply({}, o);
            delete o.callback;
            delete o.scope;
            this.lastOptions = o;
        },

        /**
         * Loads the Record cache from the configured Proxy using the configured Reader.
         * <p>
         * If using remote paging, then the first load call must specify the <em>start</em>
         * and <em>limit</em> properties in the options.params property to establish the initial
         * position within the dataset, and the number of Records to cache on each read from the Proxy.
         * <p>
         * <strong>It is important to note that for remote data sources, loading is asynchronous,
         * and this call will return before the new data has been loaded. Perform any post-processing
         * in a callback function, or in a "load" event handler.</strong>
         * <p>
         * @param {Object} options An object containing properties which control loading options:
         * <pre><code>
     params {Object} An object containing properties to pass as HTTP parameters to a remote data source.
     callback {Function} A function to be called after the Records have been loaded. The callback is
     passed the following arguments:
       r : Ext.data.Record[]
       options: Options object from the load call
       success: Boolean success indicator
     scope {Object} Scope with which to call the callback (defaults to the Store object)
     append {Boolean} indicator to append loaded records rather than replace the current cache.
     * </code></pre>
         */
        load : function(options){
            options = options || {};
            if(this.fireEvent("beforeload", this, options) !== false){
                this.storeOptions(options);
                var p = Ext.apply(options.params || {}, this.baseParams);
                if(this.sortInfo && this.remoteSort){
                    var pn = this.paramNames;
                    p[pn["sort"]] = this.sortInfo.field;
                    p[pn["dir"]] = this.sortInfo.direction;
                }
                this.proxy.load(p, this.reader, this.loadRecords, this, options);
            }
        },

        /**
         * Reloads the Record cache from the configured Proxy using the configured Reader and
         * the options from the last load operation performed.
         * @param {Object} options (optional) An object containing properties which may override the options
         * used in the last load operation. See {@link #load} for details (defaults to null, in which case
         * the most recently used options are reused).
         */
        reload : function(options){
            this.load(Ext.applyIf(options||{}, this.lastOptions));
        },

        // private
        // Called as a callback by the Reader during a load operation.
        loadRecords : function(o, options, success){
            if(!o || success === false){
                if(success !== false){
                    this.fireEvent("load", this, [], options);
                }
                if(options.callback){
                    options.callback.call(options.scope || this, [], options, false);
                }
                return;
            }
            var r = o.records, t = o.totalRecords || r.length;
            for(var i = 0, len = r.length; i < len; i++){
                r[i].join(this);
            }
            if(!options || options.add !== true){
                this.data.clear();
                this.data.addAll(r);
                this.totalLength = t;
                this.applySort();
                this.fireEvent("datachanged", this);
            }else{
                this.totalLength = Math.max(t, this.data.length+r.length);
                this.data.addAll(r);
            }
            this.fireEvent("load", this, r, options);
            if(options.callback){
                options.callback.call(options.scope || this, r, options, true);
            }
        },

        /**
         * Loads data from a passed data block. A Reader which understands the format of the data
         * must have been configured in the constructor.
         * @param {Object} data The data block from which to read the Records.  The format of the data expected
         * is dependent on the type of Reader that is configured and should correspond to that Reader's readRecords parameter.
         * @param {Boolean} append (Optional) True to append the new Records rather than replace the existing cache.
         */
        loadData : function(o, append){
            var r = this.reader.readRecords(o);
            this.loadRecords(r, {add: append}, true);
        },

        /**
         * Gets the number of cached records.
         * <p>
         * <em>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 getTotalCount() function returns
         * the data set size</em>
         */
        getCount : function(){
            return this.data.length || 0;
        },

        /**
         * Gets the total number of records in the dataset.
         * <p>
         * <em>If using paging, for this to be accurate, the data object used by the Reader must contain
         * the dataset size</em>
         */
        getTotalCount : function(){
            return this.totalLength || 0;
        },

        /**
         * Returns the sort state of the Store as an object with two properties:
         * <pre><code>
     field {String} The name of the field by which the Records are sorted
     direction {String} The sort order, "ASC" or "DESC"
         * </code></pre>
         */
        getSortState : function(){
            return this.sortInfo;
        },

        // private
        applySort : function(){
            if(this.sortInfo && !this.remoteSort){
                var s = this.sortInfo, f = s.field;
                var st = this.fields.get(f).sortType;
                var fn = function(r1, r2){
                    var v1 = st(r1.data[f]), v2 = st(r2.data[f]);
                    return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
                };
                this.data.sort(s.direction, fn);
                if(this.snapshot && this.snapshot != this.data){
                    this.snapshot.sort(s.direction, fn);
                }
            }
        },

        /**
         * Sets the default sort column and order to be used by the next load operation.
         * @param {String} fieldName The name of the field to sort by.
         * @param {String} dir (optional) The sort order, "ASC" or "DESC" (defaults to "ASC")
         */
        setDefaultSort : function(field, dir){
            this.sortInfo = {field: field, direction: dir ? dir.toUpperCase() : "ASC"};
        },

        /**
         * Sort the Records.
         * If remote sorting is used, the sort is performed on the server, and the cache is
         * reloaded. If local sorting is used, the cache is sorted internally.
         * @param {String} fieldName The name of the field to sort by.
         * @param {String} dir (optional) The sort order, "ASC" or "DESC" (defaults to "ASC")
         */
        sort : function(fieldName, dir){
            var f = this.fields.get(fieldName);
            if(!dir){
                if(this.sortInfo && this.sortInfo.field == f.name){ // toggle sort dir
                    dir = (this.sortToggle[f.name] || "ASC").toggle("ASC", "DESC");
                }else{
                    dir = f.sortDir;
                }
            }
            this.sortToggle[f.name] = dir;
            this.sortInfo = {field: f.name, direction: dir};
            if(!this.remoteSort){
                this.applySort();
                this.fireEvent("datachanged", this);
            }else{
                this.load(this.lastOptions);
            }
        },

        /**
         * Calls the specified function for each of the Records in the cache.
         * @param {Function} fn The function to call. The Record is passed as the first parameter.
         * Returning <em>false</em> aborts and exits the iteration.
         * @param {Object} scope (optional) The scope in which to call the function (defaults to the Record).
         */
        each : function(fn, scope){
            this.data.each(fn, scope);
        },

        /**
         * Get all records modified since the last load, or since the last commit.
         * @return {Ext.data.Record[]} An array of Records containing outstanding modifications.
         */
        getModifiedRecords : function(){
            return this.modified;
        },

        /**
         * Filter the records by a specified property.
         * @param {String} field A field on your records
         * @param {String/RegExp} value Either a string that the field
         * should start with or a RegExp to test against the field
         * @return {Boolean} True if the filter matched at least one record, else false
         */
        filter : function(property, value){
            if(!value.exec){ // not a regex
                value = String(value);
                if(value.length == 0){
                    return this.clearFilter();
                }
                value = new RegExp("^" + Ext.escapeRe(value), "i");
            }
            this.filterBy(function(r){
                return value.test(r.data[property]);
            });
        },

        /**
         * Filter by a function. The specified function will be called with each
         * record in this data source. If the function returns true the record is included,
         * otherwise it is filtered.
         * @param {Function} fn The function to be called, it will receive 2 args (record, id)
         * @param {Object} scope (optional) The scope of the function (defaults to this)
         */
        filterBy : function(fn, scope){
            var data = this.snapshot || this.data;
            this.snapshot = data;
            this.data = data.filterBy(fn, scope);
            this.fireEvent("datachanged", this);
        },

        /**
         * Revert to a view of the Record cache with no filtering applied.
         * @param {Boolean} suppressEvent If true the filter is cleared silently without notifying listeners
         */
        clearFilter : function(suppressEvent){
            if(this.snapshot && this.snapshot != this.data){
                this.data = this.snapshot;
                delete this.snapshot;
                if(suppressEvent !== true){
                    this.fireEvent("datachanged", this);
                }
            }
        },

        // private
        afterEdit : function(record){
            if(this.modified.indexOf(record) == -1){
                this.modified.push(record);
            }
            this.fireEvent("update", this, record, Ext.data.Record.EDIT);
        },

        // private
        afterReject : function(record){
            this.modified.remove(record);
            this.fireEvent("update", this, record, Ext.data.Record.REJECT);
        },

        // private
        afterCommit : function(record){
            this.modified.remove(record);
            this.fireEvent("update", this, record, Ext.data.Record.COMMIT);
        },

        /**
         * Commit all Records with outstanding changes. To handle updates for changes, subscribe to the
         * Store's "update" event, and perform updating when the third parameter is Ext.data.Record.COMMIT.
         */
        commitChanges : function(){
            var m = this.modified.slice(0);
            this.modified = [];
            for(var i = 0, len = m.length; i < len; i++){
                m[i].commit();
            }
        },

        /**
         * Cancel outstanding changes on all changed records.
         */
        rejectChanges : function(){
            var m = this.modified.slice(0);
            this.modified = [];
            for(var i = 0, len = m.length; i < len; i++){
                m[i].reject();
            }
        }
    });

Ext - Copyright © 2006-2007 Ext JS, LLC
All rights reserved.