/*
This file is part of Ext JS 4.2
Copyright (c) 2011-2013 Sencha Inc
Contact: http://www.sencha.com/contact
GNU General Public License Usage
This file may be used under the terms of the GNU General Public License version 3.0 as
published by the Free Software Foundation and appearing in the file LICENSE included in the
packaging of this file.
Please review the following information to ensure the GNU General Public License version 3.0
requirements will be met: http://www.gnu.org/copyleft/gpl.html.
If you are unsure which license is appropriate for your use, please contact the sales department
at http://www.sencha.com/contact.
Build date: 2013-05-16 14:36:50 (f9be68accb407158ba2b1be2c226a6ce1f649314)
*/
/**
* @private
* @class Ext.util.LruCache
* @extend Ext.util.HashMap
* A linked {@link Ext.util.HashMap HashMap} implementation which maintains most recently accessed
* items at the end of the list, and purges the cache down to the most recently accessed {@link #maxSize} items
* upon add.
*/
Ext.define('Ext.util.LruCache', {
extend: 'Ext.util.HashMap',
/**
* @cfg {Number} maxSize The maximum size the cache is allowed to grow to before further additions cause
* removal of the least recently used entry.
*/
constructor: function(config) {
Ext.apply(this, config);
this.callParent([config]);
},
/*
* @inheritdoc
*/
add: function(key, newValue) {
var me = this,
existingKey = me.findKey(newValue),
entry;
// "new" value is in the list.
if (existingKey) {
me.unlinkEntry(entry = me.map[existingKey]);
entry.prev = me.last;
entry.next = null;
}
// Genuinely new: create an entry for it.
else {
entry = {
prev: me.last,
next: null,
key: key,
value: newValue
};
}
// If the list is not empty, update the last entry
if (me.last) {
me.last.next = entry;
}
// List is empty
else {
me.first = entry;
}
me.last = entry;
me.callParent([key, entry]);
me.prune();
return newValue;
},
// @private
insertBefore: function(key, newValue, sibling) {
var me = this,
existingKey,
entry;
// NOT an assignment.
// If there is a following sibling
if (sibling = this.map[this.findKey(sibling)]) {
existingKey = me.findKey(newValue);
// "new" value is in the list.
if (existingKey) {
me.unlinkEntry(entry = me.map[existingKey]);
}
// Genuinely new: create an entry for it.
else {
entry = {
prev: sibling.prev,
next: sibling,
key: key,
value: newValue
};
}
if (sibling.prev) {
entry.prev.next = entry;
} else {
me.first = entry;
}
entry.next = sibling;
sibling.prev = entry;
me.prune();
return newValue;
}
// No following sibling, it's just an add.
else {
return me.add(key, newValue);
}
},
/*
* @inheritdoc
*/
get: function(key) {
var entry = this.map[key];
if (entry) {
// If it's not the end, move to end of list on get
if (entry.next) {
this.moveToEnd(entry);
}
return entry.value;
}
},
/*
* @private
*/
removeAtKey: function(key) {
this.unlinkEntry(this.map[key]);
return this.callParent(arguments);
},
/*
* @inheritdoc
*/
clear: function(/* private */ initial) {
this.first = this.last = null;
return this.callParent(arguments);
},
// private. Only used by internal methods.
unlinkEntry: function(entry) {
// Stitch the list back up.
if (entry) {
if (entry.next) {
entry.next.prev = entry.prev;
} else {
this.last = entry.prev;
}
if (entry.prev) {
entry.prev.next = entry.next;
} else {
this.first = entry.next;
}
entry.prev = entry.next = null;
}
},
// private. Only used by internal methods.
moveToEnd: function(entry) {
this.unlinkEntry(entry);
// NOT an assignment.
// If the list is not empty, update the last entry
if (entry.prev = this.last) {
this.last.next = entry;
}
// List is empty
else {
this.first = entry;
}
this.last = entry;
},
/*
* @private
*/
getArray: function(isKey) {
var arr = [],
entry = this.first;
while (entry) {
arr.push(isKey ? entry.key: entry.value);
entry = entry.next;
}
return arr;
},
/**
* Executes the specified function once for each item in the cache.
* Returning false from the function will cease iteration.
*
* By default, iteration is from least recently used to most recent.
*
* The paramaters passed to the function are:
* <div class="mdetail-params"><ul>
* <li><b>key</b> : String<p class="sub-desc">The key of the item</p></li>
* <li><b>value</b> : Number<p class="sub-desc">The value of the item</p></li>
* <li><b>length</b> : Number<p class="sub-desc">The total number of items in the hash</p></li>
* </ul></div>
* @param {Function} fn The function to execute.
* @param {Object} scope The scope (<code>this</code> reference) to execute in. Defaults to this LruCache.
* @param {Boolean} [reverse=false] Pass <code>true</code> to iterate the list in reverse (most recent first) order.
* @return {Ext.util.LruCache} this
*/
each: function(fn, scope, reverse) {
var me = this,
entry = reverse ? me.last : me.first,
length = me.length;
scope = scope || me;
while (entry) {
if (fn.call(scope, entry.key, entry.value, length) === false) {
break;
}
entry = reverse ? entry.prev : entry.next;
}
return me;
},
/**
* @private
*/
findKey: function(value) {
var key,
map = this.map;
for (key in map) {
// Attention. Differs from subclass in that this compares the value property
// of the entry.
if (map.hasOwnProperty(key) && map[key].value === value) {
return key;
}
}
return undefined;
},
/**
* Performs a shallow copy on this haLruCachesh.
* @return {Ext.util.HashMap} The new hash object.
*/
clone: function() {
var newCache = new this.self(this.initialConfig),
map = this.map,
key;
newCache.suspendEvents();
for (key in map) {
if (map.hasOwnProperty(key)) {
newCache.add(key, map[key].value);
}
}
newCache.resumeEvents();
return newCache;
},
/**
* Purge the least recently used entries if the maxSize has been exceeded.
*/
prune: function() {
var me = this,
purgeCount = me.maxSize ? (me.length - me.maxSize) : 0;
if (purgeCount > 0) {
for (; me.first && purgeCount; purgeCount--) {
me.removeAtKey(me.first.key);
}
}
}
/**
* @method containsKey
* @private
*/
/**
* @method contains
* @private
*/
/**
* @method getKeys
* @private
*/
/**
* @method getValues
* @private
*/
});
|
Download
