private void Touch(int key)
{
LRUCacheItem item = _dict[key];
if (item == _head)
{
//do nothing
}
else
{
LRUCacheItem prev = item.previous;
LRUCacheItem nex = item.next;
prev.next = nex;
if (nex == null)
{
_tail = prev;
}
else
{
nex.previous = prev;
}
item.next = _head;
item.previous = null;
_head.previous = item;
_head = item;
}
}
public void add(K key, V val)
{
if (cacheMap.Count >= capacity)
{
removeFirst();
}
LRUCacheItem<K, V> cacheItem = new LRUCacheItem<K, V>(key, val);
LinkedListNode<LRUCacheItem<K, V>> node = new LinkedListNode<LRUCacheItem<K, V>>(cacheItem);
lruList.AddLast(node);
cacheMap.Add(key, node);
}
public void Add(K key, V val)
{
if (cacheMap.Count >= Capacity)
{
RemoveLeastRecentlyUsed();
}
var cacheItem = new LRUCacheItem <K, V>(key, val);
var node = new LinkedListNode <LRUCacheItem <K, V> >(cacheItem);
lruList.AddLast(node);
cacheMap.Add(key, node);
}
public void Add(TKey key, TValue val)
{
if (cacheMap.Count >= capacity)
{
RemoveFirst();
}
var cacheItem = new LRUCacheItem(key, val);
var node = new LinkedListNode <LRUCacheItem>(cacheItem);
lruList.AddLast(node);
cacheMap.Add(key, node);
}
public void Add(K key, V val)
{
if (_cacheMap.Count >= capacity)
{
RemoveFirst();
}
LRUCacheItem cacheItem = new LRUCacheItem(key, val);
LinkedListNode <LRUCacheItem> node = new LinkedListNode <LRUCacheItem>(cacheItem);
_lruList.AddLast(node);
_cacheMap.Add(key, node);
}
public void Add(TKey key, TValue val)
{
if (m_cacheMap.Count >= m_capacity)
{
var first = m_lruList.First;
m_lruList.RemoveFirst();
m_cacheMap.Remove(first.Value.Key);
}
var cacheItem = new LRUCacheItem(key, val);
var node = new LinkedListNode <LRUCacheItem>(cacheItem);
m_lruList.AddLast(node);
m_cacheMap.Add(key, node);
}
public override void Put(TKey key, TValue value)
{
lock (_lockObj)
{
if (_cacheMap.ContainsKey(key))
{
return;
}
this.CheckSize(key, value);
LRUCacheItem <TKey, TValue> cacheItem = new LRUCacheItem <TKey, TValue>(key, value);
LinkedListNode <LRUCacheItem <TKey, TValue> > node =
new LinkedListNode <LRUCacheItem <TKey, TValue> >(cacheItem);
_lruList.AddLast(node);
_cacheMap.Add(key, node);
}
}
public bool TryAdd(TKey key, TValue value)
{
lock (_lockObj)
{
CleanAbandonedItems();
if (_cacheMap.ContainsKey(key))
{
return(false);
}
this.CheckSize(key, value);
LRUCacheItem <TKey, TValue> cacheItem = new LRUCacheItem <TKey, TValue>(key, value);
LinkedListNode <LRUCacheItem <TKey, TValue> > node =
new LinkedListNode <LRUCacheItem <TKey, TValue> >(cacheItem);
_lruList.AddLast(node);
_cacheMap.Add(key, node);
return(true);
}
}
public void add(K key, V val)
{
rwLock.EnterWriteLock();
try
{
if (cacheMap.Count >= capacity)
{
RemoveFirst();
}
LRUCacheItem <K, V> cacheItem = new LRUCacheItem <K, V>(key, val);
LinkedListNode <LRUCacheItem <K, V> > node = new LinkedListNode <LRUCacheItem <K, V> >(cacheItem);
lruList.AddLast(node);
cacheMap.Add(key, node);
}
finally
{
rwLock.ExitWriteLock();
}
}
public void Set(K key, V val)
{
lock (this)
{
LinkedListNode <LRUCacheItem> node;
if (_cacheMap.TryGetValue(key, out node))
{
_lruList.Remove(node);
_cacheMap.Remove(key);
}
if (_cacheMap.Count >= _capacity)
{
RemoveFirst();
}
var cacheItem = new LRUCacheItem(key, val);
node = new LinkedListNode <LRUCacheItem>(cacheItem);
_lruList.AddLast(node);
_cacheMap.Add(key, node);
}
}
public void Add(K key, V val)
{
if (cacheMap.TryGetValue(key, out LinkedListNode <LRUCacheItem> _))
{
return;
}
if (cacheMap.Count >= capacity)
{
// Remove from LRUPriority
LinkedListNode <LRUCacheItem> first = lruList.First;
lruList.RemoveFirst();
// Remove from cache
cacheMap.Remove(first.Value.key);
}
LRUCacheItem cacheItem = new LRUCacheItem(key, val);
LinkedListNode <LRUCacheItem> node = new LinkedListNode <LRUCacheItem>(cacheItem);
lruList.AddLast(node);
cacheMap.Add(key, node);
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="discaredKey"></param>
/// <param name="discardedValue"></param>
/// <returns></returns>
public bool AddDiscard(Key key, Value value, out Key discaredKey, out Value discardedValue)
{
bool retValue = false;
if (cacheMap.Count >= capacity)
{
retValue = true;
Discard(out discaredKey, out discardedValue);
}
else
{
retValue = false;
discardedValue = default(Value);
discaredKey = default(Key);
}
var cacheItem = new LRUCacheItem(key, value);
var node = new LinkedListNode <LRUCacheItem>(cacheItem);
lruList.AddLast(node);
cacheMap.Add(key, node);
return(retValue);
}
public void Add(K key, V val, out V removed)
{
lock (_lruList)
{
removed = default(V);
if (_cacheMap.Count >= _capacity)
{
removed = RemoveFirst();
}
LRUCacheItem <K, V> cacheItem = new LRUCacheItem <K, V>(key, val);
LinkedListNode <LRUCacheItem <K, V> > node = new LinkedListNode <LRUCacheItem <K, V> >(cacheItem);
_lruList.AddLast(node);
if (!_cacheMap.ContainsKey(key))
{
_cacheMap.Add(key, node);
}
else
{
_cacheMap[key] = node;
}
}
}
public override bool Equals(object obj)
{
LRUCacheItem <TKey, TValue> item = obj as LRUCacheItem <TKey, TValue>;
return(item != null && Key.Equals(item.Key));
}
public void Put(int key, int value)
{
if (_dict.ContainsKey(key))
{
//Set instead of insert
_dict[key].value = value;
Touch(key);
return;
}
if (_currentCount < _capacity)
{
//add to the Doubly linked list
LRUCacheItem item = new LRUCacheItem();
item.key = key;
item.value = value;
item.next = null; //by default
item.previous = null; //by default
_dict.Add(key, item);
if (_head == null)
{
//very very first item
_head = item;
_tail = item;
}
else
{
//add to the front
item.next = _head;
_head.previous = item;
_head = item;
}
_currentCount++;
}
else
{
//Reached Capacity
//find the least recent used item
int tailkey = _tail.key;
//remove it from Doubly Linked List
LRUCacheItem prev = _tail.previous;
if (prev != null)
{
prev.next = null;
_tail = prev;
}
else
{
//to handle 1 capacity
_tail = null;
}
//remove it from dict
_dict.Remove(tailkey);
_currentCount--;
//try again
Put(key, value);
}
}
private async void HandleRemovedItem(LRUCacheItem <string, string> ci)
{
await CacheManager.TryDeleteAsync(MediaLRUCache.RemoveLengthPrefixFromLocalFilePath(ci.value));
}
