~admin/apache-tomcat-8.5.78.git

<!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-PageMap'>/**
</span> * @class Ext.data.PageMap
 * @extends Ext.util.LruCache
 * Private class for use by only Store when configured `buffered: true`.
 * @private
 */
Ext.define('Ext.data.PageMap', {
    extend: 'Ext.util.LruCache',
 
<span id='Ext-data-PageMap-method-clear'>    // Maintain a generation counter, so that the Store can reject incoming pages destined for the previous generation
</span>    clear: function(initial) {
        var me = this;
        me.pageMapGeneration = (me.pageMapGeneration || 0) + 1;
        me.callParent(arguments);
    },
 
<span id='Ext-data-PageMap-method-forEach'>    forEach: function(fn, scope) {
</span>        var me = this,
            pageNumbers = Ext.Object.getKeys(me.map),
            pageCount = pageNumbers.length,
            i, j,
            pageNumber,
            page,
            pageSize;
 
        for (i = 0; i &lt; pageCount; i++) {
            pageNumbers[i] = Number(pageNumbers[i]);
        }
        Ext.Array.sort(pageNumbers);
        scope = scope || me;
        for (i = 0; i &lt; pageCount; i++) {
            pageNumber = pageNumbers[i];
            page = me.getPage(pageNumber);
            pageSize = page.length;
            for (j = 0; j &lt; pageSize; j++) {
                if (fn.call(scope, page[j], (pageNumber - 1) * me.pageSize + j) === false) {
                    return;
                }
            }
        }
    },
 
<span id='Ext-data-PageMap-method-findBy'>    /**
</span>    * Returns the first record in this page map which elicits a true return value from the
    * passed selection function.
    *
    * **IMPORTANT
    * This can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently
    * visible zone, or recently visited zones if the pages have not yet been purged from the cache.
    * 
    * This CAN NOT find records which have not been loaded into the cache.**
    *
    * If full client side searching is required, do not use a buffered store, instead use a regular, fully loaded store and
    * use the {@link Ext.grid.plugin.BufferedRenderer BufferedRenderer} plugin to minimize DOM footprint.
    * @param {Function} fn The selection function to execute for each item.
    *  @param {Mixed} fn.rec The record.
    *  @param {Mixed} fn.index The index in the total dataset of the record.
    * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to this PageMap.
    * @return {Object} The first record in this page map which returned true from the selection
    * function, or null if none was found.
    */
    findBy: function(fn, scope) {
        var me = this,
            result = null;
 
        scope = scope || me;
        me.forEach(function(rec, index) {
            if (fn.call(scope, rec, index)) {
                result = rec;
                return false;
            }
        });
        return result;
    },
 
<span id='Ext-data-PageMap-method-findIndexBy'>    /**
</span>    * Returns the index *in the whole dataset* of the first record in this page map which elicits a true return value from the
    * passed selection function.
    *
    * **IMPORTANT
    * This can ONLY find records which happen to be cached in the page cache. This will be parts of the dataset around the currently
    * visible zone, or recently visited zones if the pages have not yet been purged from the cache.
    * 
    * This CAN NOT find records which have not been loaded into the cache.**
    *
    * If full client side searching is required, do not use a buffered store, instead use a regular, fully loaded store and
    * use the {@link Ext.grid.plugin.BufferedRenderer BufferedRenderer} plugin to minimize DOM footprint.
    * @param {Function} fn The selection function to execute for each item.
    *  @param {Mixed} fn.rec The record.
    *  @param {Mixed} fn.index The index in the total dataset of the record.
    * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to this PageMap.
    * @return {Number} The index first record in this page map which returned true from the selection
    * function, or -1 if none was found.
    */
    findIndexBy: function(fn, scope) {
        var me = this,
            result = -1;
 
        scope = scope || me;
        me.forEach(function(rec, index) {
            if (fn.call(scope, rec)) {
                result = index;
                return false;
            }
        });
        return result;
    },
 
<span id='Ext-data-PageMap-method-getPageFromRecordIndex'>    getPageFromRecordIndex: function() {
</span>        return Ext.data.Store.prototype.getPageFromRecordIndex.apply(this, arguments);
    },
 
<span id='Ext-data-PageMap-method-addAll'>    addAll: function(records) {
</span>        //&lt;debug&gt;
        if (this.getCount()) {
            Ext.Error.raise('Cannot addAll to a non-empty PageMap');
        }
        //&lt;/debug&gt;
        this.addPage(1, records);
    },
 
<span id='Ext-data-PageMap-method-addPage'>    addPage: function(pageNumber, records) {
</span>        var me = this,
            lastPage = pageNumber + Math.floor((records.length - 1) / me.pageSize),
            startIdx,
            page;
 
        // Account for being handed a block of records spanning several pages.
        // This can happen when loading from a MemoryProxy before a viewSize has been determined.
        for (startIdx = 0; pageNumber &lt;= lastPage; pageNumber++, startIdx += me.pageSize) {
            page = Ext.Array.slice(records, startIdx, startIdx + me.pageSize);
            me.add(pageNumber, page);
            me.fireEvent('pageAdded', pageNumber, page);
        }
    },
 
<span id='Ext-data-PageMap-method-getCount'>    getCount: function() {
</span>        var result = this.callParent();
        if (result) {
            result = (result - 1) * this.pageSize + this.last.value.length;
        }
        return result;
    },
 
<span id='Ext-data-PageMap-method-indexOf'>    indexOf: function(record) {
</span>        return record ? record.index : -1;
    },
 
<span id='Ext-data-PageMap-method-insert'>    insert: function() {
</span>        //&lt;debug&gt;
        Ext.Error.raise('insert operation not suppported into buffered Store');
        //&lt;/debug&gt;
    },
 
<span id='Ext-data-PageMap-method-remove'>    remove: function() {
</span>        //&lt;debug&gt;
        Ext.Error.raise('remove operation not suppported from buffered Store');
        //&lt;/debug&gt;
    },
 
<span id='Ext-data-PageMap-method-removeAt'>    removeAt: function() {
</span>        //&lt;debug&gt;
        Ext.Error.raise('removeAt operation not suppported from buffered Store');
        //&lt;/debug&gt;
    },
 
<span id='Ext-data-PageMap-method-getPage'>    getPage: function(pageNumber) {
</span>        return this.get(pageNumber);
    },
 
<span id='Ext-data-PageMap-method-hasRange'>    hasRange: function(start, end) {
</span>        var pageNumber = this.getPageFromRecordIndex(start),
            endPageNumber = this.getPageFromRecordIndex(end);
 
        for (; pageNumber &lt;= endPageNumber; pageNumber++) {
            if (!this.hasPage(pageNumber)) {
                return false;
            }
        }
        return true;
    },
 
<span id='Ext-data-PageMap-method-hasPage'>    hasPage: function(pageNumber) {
</span>        // We must use this.get to trigger an access so that the page which is checked for presence is not eligible for pruning
        return !!this.get(pageNumber);
    },
 
<span id='Ext-data-PageMap-method-getAt'>    getAt: function(index) {
</span>        return this.getRange(index, index)[0];
    },
 
<span id='Ext-data-PageMap-method-getRange'>    getRange: function(start, end) {
</span>        if (!this.hasRange(start, end)) {
            Ext.Error.raise('PageMap asked for range which it does not have');
        }
        var me = this,
            startPageNumber = me.getPageFromRecordIndex(start),
            endPageNumber = me.getPageFromRecordIndex(end),
            dataStart = (startPageNumber - 1) * me.pageSize,
            dataEnd = (endPageNumber * me.pageSize) - 1,
            pageNumber = startPageNumber,
            result = [],
            sliceBegin, sliceEnd, doSlice,
            i = 0, len;
 
        for (; pageNumber &lt;= endPageNumber; pageNumber++) {
 
            // First and last pages will need slicing to cut into the actual wanted records
            if (pageNumber == startPageNumber) {
                sliceBegin = start - dataStart;
                doSlice = true;
            } else {
                sliceBegin = 0;
                doSlice = false;
            }
            if (pageNumber == endPageNumber) {
                sliceEnd = me.pageSize - (dataEnd - end);
                doSlice = true;
            }
 
            // First and last pages will need slicing
            if (doSlice) {
                Ext.Array.push(result, Ext.Array.slice(me.getPage(pageNumber), sliceBegin, sliceEnd));
            } else {
                Ext.Array.push(result, me.getPage(pageNumber));
            }
        }
 
        // Inject the dataset ordinal position into the record as the index
        for (len = result.length; i &lt; len; i++) {
            result[i].index = start++;
        }
        return result;
    }
});</pre>
</body>
</html>