add extjs 6.0.1 sources

[extjs.git] / extjs / packages / core / src / util / LruCache.js

/**\r
 * @private\r
 * @class Ext.util.LruCache\r
 * @extend Ext.util.HashMap\r
 * A linked {@link Ext.util.HashMap HashMap} implementation which maintains most recently accessed\r
 * items at the end of the list, and purges the cache down to the most recently accessed {@link #maxSize} items\r
 * upon add.\r
 */\r
Ext.define('Ext.util.LruCache', {\r
    extend: 'Ext.util.HashMap',\r
\r
    config: {\r
        /** \r
        * @cfg {Number} maxSize The maximum size the cache is allowed to grow to before further additions cause\r
        * removal of the least recently used entry.\r
        */\r
       maxSize: null\r
   },\r
\r
    /**\r
     * @inheritdoc\r
     */\r
    add: function(key, newValue) {\r
        var me = this,\r
            entry, last;\r
\r
        me.removeAtKey(key);\r
        last = me.last;\r
        entry = {\r
            prev: last,\r
            next: null,\r
            key: key,\r
            value: newValue\r
        };\r
\r
        \r
        if (last) {\r
            // If the list is not empty, update the last entry\r
            last.next = entry;\r
        } else {\r
            // List is empty\r
            me.first = entry;\r
        }\r
        me.last = entry;\r
        me.callParent([key, entry]);\r
        me.prune();\r
        return newValue;\r
    },\r
\r
    /**\r
     * @private\r
     */\r
    insertBefore: function(key, newValue, sibling) {\r
        var me = this,\r
            existingKey,\r
            entry;\r
\r
        // NOT an assignment.\r
        // If there is a following sibling\r
        if (sibling = this.map[this.findKey(sibling)]) {\r
            existingKey = me.findKey(newValue);\r
\r
            // "new" value is in the list.\r
            if (existingKey) {\r
                me.unlinkEntry(entry = me.map[existingKey]);\r
            }\r
            // Genuinely new: create an entry for it.\r
            else {\r
                entry = {\r
                    prev: sibling.prev,\r
                    next: sibling,\r
                    key: key,\r
                    value: newValue\r
                };\r
            }\r
\r
            if (sibling.prev) {\r
                entry.prev.next = entry;\r
            } else {\r
                me.first = entry;\r
            }\r
            entry.next = sibling;\r
            sibling.prev = entry;\r
            me.prune();\r
            return newValue;\r
        }\r
        // No following sibling, it's just an add.\r
        else {\r
            return me.add(key, newValue);\r
        }\r
    },\r
\r
    /**\r
     * @inheritdoc\r
     */\r
    get: function(key) {\r
        var entry = this.map[key];\r
        if (entry) {\r
\r
            // If it's not the end, move to end of list on get\r
            if (entry.next) {\r
                this.moveToEnd(entry);\r
            }\r
            return entry.value;\r
        }\r
    },\r
\r
    /**\r
     * @private\r
     */\r
    removeAtKey: function(key) {\r
        this.unlinkEntry(this.map[key]);\r
        return this.callParent(arguments);\r
    },\r
\r
    /**\r
     * @inheritdoc\r
     */\r
    clear: function(/* private */ initial) {\r
        this.first = this.last = null;\r
        return this.callParent([initial]);\r
    },\r
\r
    /**\r
     * @private\r
     */\r
    unlinkEntry: function(entry) {\r
        // Stitch the list back up.\r
        if (entry) {\r
            if (entry.next) {\r
                entry.next.prev = entry.prev;\r
            } else {\r
                this.last = entry.prev;\r
            }\r
            if (entry.prev) {\r
                entry.prev.next = entry.next;\r
            } else {\r
                this.first = entry.next;\r
            }\r
            entry.prev = entry.next = null;\r
        }\r
    },\r
\r
    /**\r
     * @private\r
     */\r
    moveToEnd: function(entry) {\r
        this.unlinkEntry(entry);\r
\r
        // NOT an assignment.\r
        // If the list is not empty, update the last entry\r
        if (entry.prev = this.last) {\r
            this.last.next = entry;\r
        }\r
        // List is empty\r
        else {\r
            this.first = entry;\r
        }\r
        this.last = entry;\r
    },\r
\r
    /**\r
     * @private\r
     */\r
    getArray: function(isKey) {\r
        var arr = [],\r
            entry = this.first;\r
\r
        while (entry) {\r
            arr.push(isKey ? entry.key: entry.value);\r
            entry = entry.next;\r
        }\r
        return arr;\r
    },\r
\r
    /**\r
     * Executes the specified function once for each item in the cache.\r
     * Returning false from the function will cease iteration.\r
     *\r
     * By default, iteration is from least recently used to most recent.\r
     *\r
     * The paramaters passed to the function are:\r
     * <div class="mdetail-params"><ul>\r
     * <li><b>key</b> : String<p class="sub-desc">The key of the item</p></li>\r
     * <li><b>value</b> : Number<p class="sub-desc">The value of the item</p></li>\r
     * <li><b>length</b> : Number<p class="sub-desc">The total number of items in the hash</p></li>\r
     * </ul></div>\r
     * @param {Function} fn The function to execute.\r
     * @param {Object} scope The scope (<code>this</code> reference) to execute in. Defaults to this LruCache.\r
     * @param {Boolean} [reverse=false] Pass <code>true</code> to iterate the list in reverse (most recent first) order.\r
     * @return {Ext.util.LruCache} this\r
     */\r
    each: function(fn, scope, reverse) {\r
        var me = this,\r
            entry = reverse ? me.last : me.first,\r
            length = me.length;\r
\r
        scope = scope || me;\r
        while (entry) {\r
            if (fn.call(scope, entry.key, entry.value, length) === false) {\r
                break;\r
            }\r
            entry = reverse ? entry.prev : entry.next;\r
        }\r
        return me;\r
    },\r
\r
    /**\r
     * @private\r
     */\r
    findKey: function(value) {\r
        var key,\r
            map = this.map;\r
\r
        for (key in map) {\r
            // Attention. Differs from subclass in that this compares the value property\r
            // of the entry.\r
            if (map.hasOwnProperty(key) && map[key].value === value) {\r
                return key;\r
            }\r
        }\r
        return undefined;\r
    },\r
\r
    /**\r
     * Performs a shallow copy on this haLruCachesh.\r
     * @return {Ext.util.HashMap} The new hash object.\r
     */\r
    clone: function() {\r
        var newCache = new this.self(this.initialConfig),\r
            map = this.map,\r
            key;\r
\r
        newCache.suspendEvents();\r
        for (key in map) {\r
            if (map.hasOwnProperty(key)) {\r
                newCache.add(key, map[key].value);\r
            }\r
        }\r
        newCache.resumeEvents();\r
        return newCache;\r
    },\r
\r
    /**\r
     * Purge the least recently used entries if the maxSize has been exceeded.\r
     */\r
    prune: function() {\r
        var me = this,\r
            max = me.getMaxSize(),\r
            purgeCount = max ? (me.length - max) : 0;\r
\r
        if (purgeCount > 0) {\r
            for (; me.first && purgeCount; purgeCount--) {\r
                me.removeAtKey(me.first.key);\r
            }\r
        }\r
    },\r
\r
    destroy: function() {\r
        this.first = this.last = null;\r
        this.callParent();     \r
    }\r
\r
  /**\r
   * @method containsKey\r
   * @private\r
   */\r
  /**\r
   * @method contains\r
   * @private\r
   */\r
  /**\r
   * @method getKeys\r
   * @private\r
   */\r
  /**\r
   * @method getValues\r
   * @private\r
   */\r
});