add extjs 6.0.1 sources

[extjs.git] / extjs / packages / core / src / data / PageMap.js

/**\r
 * @class Ext.data.PageMap\r
 * @extends Ext.util.LruCache\r
 * Private class for use by only Store when configured `buffered: true`.\r
 * @private\r
 */\r
Ext.define('Ext.data.PageMap', {\r
    extend: 'Ext.util.LruCache',\r
\r
    config: {\r
        store: null,\r
\r
        /**\r
         * @cfg {Number} pageSize\r
         * The size of pages in this map.\r
         */\r
        pageSize: 0,\r
\r
        /**\r
         * @cfg {String} rootProperty\r
         * The root property to use for aggregation, filtering and sorting. By default\r
         * this is `null` but when containing things like {@link Ext.data.Model records}\r
         * this config would likely be set to "data" so that property names are applied\r
         * to the fields of each record.\r
         */\r
        rootProperty: ''\r
    },\r
\r
    // Maintain a generation counter, so that the Store can reject incoming pages destined for the previous generation\r
    clear: function(initial) {\r
        var me = this;\r
        me.pageMapGeneration = (me.pageMapGeneration || 0) + 1;\r
\r
        // Map of internalId to recordIndex\r
        me.indexMap = {};\r
\r
        me.callParent([initial]);\r
    },\r
\r
    //<debug>\r
    updatePageSize: function(value, oldValue) {\r
        if (oldValue != null) {\r
            throw "pageMap page size may not be changed";\r
        }\r
    },\r
    //</debug>\r
\r
    forEach: function(fn, scope) {\r
        var me = this,\r
            pageNumbers = Ext.Object.getKeys(me.map),\r
            pageCount = pageNumbers.length,\r
            pageSize = me.getPageSize(),\r
            i, j,\r
            pageNumber,\r
            page,\r
            len;\r
\r
        for (i = 0; i < pageCount; i++) {\r
            pageNumbers[i] = +pageNumbers[i];\r
        }\r
        Ext.Array.sort(pageNumbers, Ext.Array.numericSortFn);\r
        scope = scope || me;\r
        for (i = 0; i < pageCount; i++) {\r
            pageNumber = pageNumbers[i];\r
            page = me.getPage(pageNumber);\r
            len = page.length;\r
            for (j = 0; j < len; j++) {\r
                if (fn.call(scope, page[j], (pageNumber - 1) * pageSize + j) === false) {\r
                    return;\r
                }\r
            }\r
        }\r
    },\r
\r
    /**\r
    * Returns the first record in this page map which elicits a true return value from the\r
    * passed selection function.\r
    *\r
    * **IMPORTANT\r
    * This can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently\r
    * visible zone, or recently visited zones if the pages have not yet been purged from the cache.\r
    * \r
    * This CAN NOT find records which have not been loaded into the cache.**\r
    *\r
    * If full client side searching is required, do not use a buffered store, instead use a regular, fully loaded store and\r
    * use the {@link Ext.grid.plugin.BufferedRenderer BufferedRenderer} plugin to minimize DOM footprint.\r
    * @param {Function} fn The selection function to execute for each item.\r
    *  @param {Mixed} fn.rec The record.\r
    *  @param {Mixed} fn.index The index in the total dataset of the record.\r
    * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to this PageMap.\r
    * @return {Object} The first record in this page map which returned true from the selection\r
    * function, or null if none was found.\r
    */\r
    findBy: function(fn, scope) {\r
        var me = this,\r
            result = null;\r
\r
        scope = scope || me;\r
        me.forEach(function(rec, index) {\r
            if (fn.call(scope, rec, index)) {\r
                result = rec;\r
                return false;\r
            }\r
        });\r
        return result;\r
    },\r
\r
    /**\r
    * Returns the index *in the whole dataset* of the first record in this page map which elicits a true return value from the\r
    * passed selection function.\r
    *\r
    * **IMPORTANT\r
    * This can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently\r
    * visible zone, or recently visited zones if the pages have not yet been purged from the cache.\r
    * \r
    * This CAN NOT find records which have not been loaded into the cache.**\r
    *\r
    * If full client side searching is required, do not use a buffered store, instead use a regular, fully loaded store and\r
    * use the {@link Ext.grid.plugin.BufferedRenderer BufferedRenderer} plugin to minimize DOM footprint.\r
    * @param {Function} fn The selection function to execute for each item.\r
    *  @param {Mixed} fn.rec The record.\r
    *  @param {Mixed} fn.index The index in the total dataset of the record.\r
    * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to this PageMap.\r
    * @return {Number} The index first record in this page map which returned true from the selection\r
    * function, or -1 if none was found.\r
    */\r
    findIndexBy: function(fn, scope) {\r
        var me = this,\r
            result = -1;\r
\r
        scope = scope || me;\r
        me.forEach(function(rec, index) {\r
            if (fn.call(scope, rec)) {\r
                result = index;\r
                return false;\r
            }\r
        });\r
        return result;\r
    },\r
\r
    find: function (property, value, start, startsWith, endsWith, ignoreCase) {\r
        if (Ext.isEmpty(value, false)) {\r
            return null;\r
        }\r
\r
        var regex = Ext.String.createRegex(value, startsWith, endsWith, ignoreCase),\r
            root = this.getRootProperty();\r
\r
        return this.findBy(function (item) {\r
            return item && regex.test((root ? item[root] : item)[property]);\r
        }, null, start);\r
    },\r
\r
    findIndex: function (property, value, start, startsWith, endsWith, ignoreCase) {\r
        if (Ext.isEmpty(value, false)) {\r
            return null;\r
        }\r
\r
        var regex = Ext.String.createRegex(value, startsWith, endsWith, ignoreCase),\r
            root = this.getRootProperty();\r
\r
        return this.findIndexBy(function (item) {\r
            return item && regex.test((root ? item[root] : item)[property]);\r
        }, null, start);\r
    },\r
\r
    getPageFromRecordIndex: function(index) {\r
        return Math.floor(index / this.getPageSize()) + 1;\r
    },\r
\r
    addAll: function(records) {\r
        //<debug>\r
        if (this.getCount()) {\r
            Ext.raise('Cannot addAll to a non-empty PageMap');\r
        }\r
        //</debug>\r
        this.addPage(1, records);\r
    },\r
\r
    addPage: function(pageNumber, records) {\r
        var me = this,\r
            pageSize = me.getPageSize(),\r
            lastPage = pageNumber + Math.floor((records.length - 1) / pageSize),\r
            storeIndex = (pageNumber - 1) * pageSize,\r
            indexMap = me.indexMap,\r
            page, i, len, startIdx;\r
\r
        // Account for being handed a block of records spanning several pages.\r
        // This can happen when loading from a MemoryProxy before a viewSize has been determined.\r
        for (startIdx = 0; pageNumber <= lastPage; pageNumber++, startIdx += pageSize) {\r
            page = Ext.Array.slice(records, startIdx, startIdx + pageSize);\r
\r
            // Maintain the indexMap so that we can implement indexOf(record)\r
            for (i = 0, len = page.length; i < len; i++) {\r
                indexMap[page[i].internalId] = storeIndex++;\r
            }\r
            me.add(pageNumber, page);\r
            me.fireEvent('pageadd', me, pageNumber, page);\r
        }\r
    },\r
\r
    getCount: function() {\r
        var result = this.callParent();\r
        if (result) {\r
            result = (result - 1) * this.getPageSize() + this.last.value.length;\r
        }\r
        return result;\r
    },\r
\r
    getByInternalId: function(internalId) {\r
        var index = this.indexMap[internalId];\r
        if (index != null) {\r
            return this.getAt(index);\r
        }\r
    },\r
\r
    indexOf: function(record) {\r
        var result = -1;\r
        if (record) {\r
            result = this.indexMap[record.internalId];\r
            if (result == null) {\r
                result = -1;\r
            }\r
        }\r
        return result;\r
    },\r
\r
    insert: function() {\r
        //<debug>\r
        Ext.raise('insert operation not suppported into buffered Store');\r
        //</debug>\r
    },\r
\r
    remove: function() {\r
        //<debug>\r
        Ext.raise('remove operation not suppported from buffered Store');\r
        //</debug>\r
    },\r
\r
    removeAt: function() {\r
        //<debug>\r
        Ext.raise('removeAt operation not suppported from buffered Store');\r
        //</debug>\r
    },\r
\r
    removeAtKey: function (page) {\r
        // Allow observers to veto\r
        var me = this,\r
            thePage = me.getPage(page),\r
            len,\r
            i,\r
            result;\r
\r
        if (thePage) {\r
            if (me.fireEvent('beforepageremove', me, page, thePage) !== false) {\r
                len = thePage.length;\r
                for (i = 0; i < len; i++) {\r
                    delete me.indexMap[thePage[i].internalId];\r
                }\r
                result = me.callParent(arguments);\r
                me.fireEvent('pageremove', me, page, thePage);\r
\r
                // Empty the page array *after* informing observers that the records have exited.\r
                thePage.length = 0;\r
            }\r
        }\r
        return result;\r
    },\r
\r
    getPage: function(pageNumber) {\r
        return this.get(pageNumber);\r
    },\r
\r
    hasRange: function(start, end) {\r
        var me = this,\r
            pageNumber = me.getPageFromRecordIndex(start),\r
            endPageNumber = me.getPageFromRecordIndex(end);\r
\r
        for (; pageNumber <= endPageNumber; pageNumber++) {\r
            if (!me.hasPage(pageNumber)) {\r
                return false;\r
            }\r
        }\r
        // Check that the last page is filled enough to encapsulate the range.\r
        return (endPageNumber - 1) * me._pageSize + me.getPage(endPageNumber).length > end;\r
    },\r
\r
    hasPage: function(pageNumber) {\r
        // We must use this.get to trigger an access so that the page which is checked for presence is not eligible for pruning\r
        return !!this.get(pageNumber);\r
    },\r
\r
    peekPage: function(pageNumber) {\r
        return this.map[pageNumber];\r
    },\r
\r
    getAt: function(index) {\r
        return this.getRange(index, index + 1)[0];\r
    },\r
\r
    getRange: function(start, end) {\r
        // Store's backing Collection now uses EXCLUSIVE endIndex\r
        // So store will always pass the endIndex+1\r
        end--;\r
\r
        if (!this.hasRange(start, end)) {\r
            Ext.raise('PageMap asked for range which it does not have');\r
        }\r
        var me = this,\r
            Array = Ext.Array,\r
            pageSize = me.getPageSize(),\r
            startPageNumber = me.getPageFromRecordIndex(start),\r
            endPageNumber = me.getPageFromRecordIndex(end),\r
            dataStart = (startPageNumber - 1) * pageSize,\r
            dataEnd = (endPageNumber * pageSize) - 1,\r
            pageNumber = startPageNumber,\r
            result = [],\r
            sliceBegin, sliceEnd, doSlice;\r
\r
        for (; pageNumber <= endPageNumber; pageNumber++) {\r
\r
            // First and last pages *may* need slicing to cut into the actual wanted records\r
            if (pageNumber === startPageNumber) {\r
                sliceBegin = start - dataStart;\r
                doSlice = sliceBegin > 0;\r
            } else {\r
                sliceBegin = 0;\r
                doSlice = false;\r
            }\r
            if (pageNumber === endPageNumber) {\r
                sliceEnd = pageSize - (dataEnd - end);\r
                doSlice = doSlice || sliceEnd < pageSize;\r
            }\r
\r
            // First and last pages will need slicing\r
            if (doSlice) {\r
                Array.push(result, Array.slice(me.getPage(pageNumber), sliceBegin, sliceEnd));\r
            } else {\r
                Array.push(result, me.getPage(pageNumber));\r
            }\r
        }\r
        return result;\r
    },\r
\r
    destroy: function() {\r
        this.callParent();\r
        this.indexMap = {};\r
\r
    }\r
});\r