void ICollection.CopyTo(Array array, int index)
{
if (array == null)
{
Thrower.ThrowArgumentNullException(ExceptionArgument.array);
}
int length = array.Length;
if ((index < 0) || (index > length))
{
Thrower.ThrowArgumentOutOfRangeException(ExceptionArgument.arrayIndex, ExceptionResource.ArgumentOutOfRange_Index);
}
int num2 = (length - index);
if (num2 < _size)
{
Thrower.ThrowArgumentException(ExceptionResource.Argument_InvalidOfLen);
}
// If the head is above tha tail we need to do two copies. The first copy will get
// the elements between the head and the end of the queue and the second copy will get
// the elements between the top of the queue and the tail.
if (_tail < _head)
{
int num3 = _array.Length - _head;
Array.Copy(_array, _head, array, index, num3);
Array.Copy(_array, 0, array, index + num3, _tail);
}
else
{
Array.Copy(_array, _head, array, index, _head - _tail);
}
}
/// <summary>
/// Initializes a new instance_ onf the CacheEntry class by using the specified item key and value and
/// expiration police.
/// </summary>
/// <param name="key">The cache key used to reference the item.</param>
/// <param name="value">The item to be added to the cache.</param>
/// <param name="utcAbsoluteExpiration">The time at which the added object expires and is removed
/// from the cache. If the sliding expiration will be used, the <paramref name="utcAbsoluteExpiration"/>
/// parameter must be <see cref="CacheEntry.NoAbsoluteExpiration"/>
/// </param>
/// <param name="slidingExpiration">The interval between the time the added object was last accessed
/// and the time at which that object expires. If the <paramref name="utcAbsoluteExpiration"/> is defined
/// the <paramref name="slidingExpiration"/> parametr must be <see cref="CacheEntry.NoSlidingExpiration"/></param>
internal CacheEntry(string key, object value, DateTime utcAbsoluteExpiration, TimeSpan slidingExpiration)
{
if (slidingExpiration < TimeSpan.Zero || OneYear < slidingExpiration)
{
throw new ArgumentNullException("value");
}
if (utcAbsoluteExpiration != NoAbsoluteExpiration && slidingExpiration != NoSlidingExpiration)
{
Thrower.ThrowArgumentException(ExceptionResource.Caching_Invalid_expiration_combination);
}
_value = value;
_utcCreated = DateTime.UtcNow;
_slidingExpiration = slidingExpiration;
_utcExpires = (_slidingExpiration > TimeSpan.Zero) ? _utcCreated + _slidingExpiration : utcAbsoluteExpiration;
_key = key;
}
/// <summary>
/// Copies the elements of the <see cref="AndersonTree{TKey,TValue}"/> to
/// an <see cref="Array"/>, starting at a particular index.
/// </summary>
/// <param name="array">
/// The one-dimensional <see cref="Array"/> that is the destination of the
/// elements copied from the <see cref="AndersonTree{TKey,TValue}"/>.
/// The array must have zero-based indexing.
/// </param>
/// <param name="index">
/// The zero-based index in array at which copying begins.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="index"/> is less than 0.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="array"/>is <c>null</c>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="array"/> is multidimensional.-or-
/// <paramref name="index"/> is equal to or greater than the length of the
/// array.-or-The number of elements in the source
/// <see cref="AndersonTree{TKey,TValue}"/>is greater than the
/// available space from <paramref name="index"/> to the end of the
/// destination array.-or- <see cref=" KeyValuePair{TKey,TValue}"/> cannot
/// be cast automatically to the type of the destination array.
/// </exception>
public void CopyTo(KeyValuePair <TKey, TValue>[] array, int index)
{
if ((index < 0) || (index > array.Length))
{
Thrower.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
}
if ((array.Length - index) < count_)
{
Thrower.ThrowArgumentException(
ExceptionResource.Arg_ArrayPlusOffTooSmall);
}
if (count_ == 0)
{
return;
}
InOrderTreeWalk(delegate(AndersonTreeNode <TKey, TValue> node)
{
array[index++] = node.ToKeyValuePair();
return(true);
});
}
public void ThrowArgumentException()
{
Thrower.ThrowArgumentException(ExceptionResource.Argument_Empty);
}
/// <summary>
/// Inserts an item to the AndersonTree
/// </summary>
/// <param name="key">
/// The key of the value to insert into the tree.
/// </param>
/// <param name="value">
/// The value to insert in the tree.
/// </param>
/// <param name="add">
/// A value indicating when the item will be added or modified.
/// </param>
void Insert(TKey key, TValue value, bool add)
{
if (!key_is_value_type_ && key == null)
{
Thrower.ThrowArgumentNullException(ExceptionArgument.key);
}
// empty tree
if (root_.Level == 0)
{
root_ = new AndersonTreeNode <TKey, TValue>(key, value, sentinel_);
count_++;
return;
}
int cmp, dir;
List <AndersonTreeNode <TKey, TValue> > path =
new List <AndersonTreeNode <TKey, TValue> >(count_);
AndersonTreeNode <TKey, TValue> node = root_;
// Find the place to insert the item
// - If the item is found and we trying to add a new one,
// throw an exception - no duplicate items allowed.
// - If a leaf is reached, insert the item in the correct place.
// - Else, traverse the tree further.
while (true)
{
path.Add(node);
cmp = comparer_.Compare(key, node.Key);
if (cmp == 0)
{
if (add)
{
Thrower.ThrowArgumentException(
ExceptionResource.Argument_AddingDuplicate);
}
if (node.Level != 0)
{
node.Value = value;
}
return;
}
dir = (cmp < 0) ? 0 : 1;
if (node.childs[dir].Level == 0)
{
break;
}
node = node.childs[dir];
}
// create the new node
node.childs[dir] =
new AndersonTreeNode <TKey, TValue>(key, value, sentinel_);
// Walk back and rebalance
int top = path.Count;
while (--top >= 0)
{
AndersonTreeNode <TKey, TValue> n = path[top];
// which child ?
if (top != 0)
{
dir = (path[top - 1].Right == n) ? 1 : 0;
}
Skew(ref n);
Split(ref n);
// Fix the parent
if (top != 0)
{
path[top - 1].childs[dir] = n;
}
else
{
root_ = n;
}
}
count_++;
}