/// <summary>
/// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
/// </summary>
/// <param name="key">The object to use as the key of the element to add.</param>
/// <param name="value">The object to use as the value of the element to add.</param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="key"/> is null.
/// </exception>
/// <exception cref="T:System.ArgumentException">
/// An element with the same key already exists in the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
/// </exception>
/// <exception cref="T:System.NotSupportedException">
/// The <see cref="T:System.Collections.Generic.IDictionary`2"/> is read-only.
/// </exception>
public void Add(TKey key, TValue value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
RWLock.GetWriteLock(_lock, _lockTimeout, delegate
{
// Throw out old one if reusing a key.
if (_data.ContainsKey(key))
{
Remove(key);
}
// Keep throwing out old items to make space. Stop if empty.
while (_data.Count >= _capacity)
{
if (!RemoveLru())
{
break;
}
}
if (_data.Count >= _capacity)
{
// Just not enough room.
return(false);
}
Node node = new Node(key, value);
_data.Add(key, node);
InsertNode(node);
return(true);
});
}
/// <summary>
/// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
/// </summary>
/// <param name="key">The key of the element to remove.</param>
/// <returns>
/// true if the element is successfully removed; otherwise, false. This method also returns false if <paramref name="key"/> was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2"/>.
/// </returns>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="key"/> is null.
/// </exception>
/// <exception cref="T:System.NotSupportedException">
/// The <see cref="T:System.Collections.Generic.IDictionary`2"/> is read-only.
/// </exception>
public bool Remove(TKey key)
{
return(RWLock.GetWriteLock(_lock, _lockTimeout, delegate
{
return InternalRemove(key);
}));
}
/// <summary>Remove all items from index</summary>
public void ClearIndex()
{
RWLock.GetWriteLock(_lock, LockTimeout, delegate
{
index.Clear();
return(true);
});
}
/// <summary>
/// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
/// </summary>
/// <exception cref="T:System.NotSupportedException">
/// The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.
/// </exception>
public void Clear()
{
RWLock.GetWriteLock(_lock, _lockTimeout, delegate
{
_data.Clear();
_head = null;
_tail = null;
return(true);
});
}
/// <summary>AddAsNode new item to index</summary>
/// <param name="item">item to add</param>
/// <returns>was item key previously contained in index</returns>
public bool AddItem(INode <T> item)
{
TKey key = _getKey(item.Value);
return(RWLock.GetWriteLock(_lock, LockTimeout, delegate
{
bool alreadyExisted = index.ContainsKey(key);
index[key] = new WeakReference(item, false);
return alreadyExisted;
}));
}
/// <summary>Add new item to index</summary>
/// <param name="item">item to add</param>
/// <returns>was item key previously contained in index</returns>
public bool AddItem(INode item)
{
TKey key = _getKey(item.Value);
return(RWLock.GetWriteLock(_lock, _lockTimeout, delegate
{
bool isDup = _index.ContainsKey(key);
_index[key] = new WeakReference(item, false);
return isDup;
}));
}
private bool RemoveLru()
{
return(RWLock.GetWriteLock(_lock, _lockTimeout, delegate
{
if (_tail == null)
{
return false;
}
_data.Remove(_tail.Key);
DeleteNode(_tail);
return true;
}));
}
/// <summary>removes all items from index and reloads each item (this gets rid of dead nodes)</summary>
public int RebuildIndex()
{
lock (_owner._lifeSpan)
return(RWLock.GetWriteLock(_lock, _lockTimeout, delegate
{
_index.Clear();
foreach (INode item in _owner._lifeSpan)
{
AddItem(item);
}
return _index.Count;
}));
}
/// <summary>removes all items from index and reloads each item (this gets rid of dead nodes)</summary>
public int RebuildIndex()
{
lock (lifespanManager)
{
return(RWLock.GetWriteLock(_lock, LockTimeout, delegate
{
index.Clear();
foreach (INode <T> item in lifespanManager)
{
AddItem(item);
}
return index.Count;
}));
}
}
/// <summary>
/// Adds an item.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public virtual bool AddItem(TKey key, TValue value)
{
if (!_dict.ContainsKey(key))
{
return(RWLock.GetWriteLock(
_dictLock,
RWLock.DEFAULT_RWLOCK_TIMEOUT,
() =>
{
if (!_dict.ContainsKey(key))
{
_dict.Add(key, value);
return true;
}
return false;
}
));
}
return(false);
}
/// <summary>
/// Notifies the dependency changed.
/// </summary>
/// <param name="dependency">The dependency.</param>
/// <param name="ignoreCase">if set to <c>true</c> [ignore case].</param>
/// <param name="partiallyMatch">if set to <c>true</c> [partially match].</param>
public void NotifyDependencyChanged(string dependency, bool ignoreCase, bool partiallyMatch)
{
List <DependingKey <TKey> > list = new List <DependingKey <TKey> >();
IEnumerator <DependingKey <TKey> > en = this.Keys.GetEnumerator();
RWLock.GetWriteLock(Lock, LockTimeout, delegate
{
while (en.MoveNext())
{
if (en.Current.Depends(dependency, ignoreCase, partiallyMatch))
{
list.Add(en.Current);
}
}
if (list.Count > 0)
{
for (int i = 0; i < list.Count; ++i)
{
this.InternalRemove(list[i]);
}
}
return(true);
});
}