//TODO: test
/// <summary>
/// Make a shallow copy of this SortedKeysCollection.
/// </summary>
/// <returns></returns>
public virtual object Clone()
{
//
SortedArrayDictionary <K, V> dictclone = new SortedArrayDictionary <K, V>(sortedpairs.Count, comparer, EqualityComparer);
SortedArray <KeyValuePair <K, V> > sortedpairsclone = (SortedArray <KeyValuePair <K, V> >)(dictclone.sortedpairs);
foreach (K key in sorteddict.Keys)
{
sortedpairsclone.Add(new KeyValuePair <K, V>(key, default(V)));
}
return(new SortedKeysCollection(dictclone, sortedpairsclone, comparer, EqualityComparer));
}
/// <summary>
/// Add all the items from another collection with an enumeration order that
/// is increasing in the items.
/// <exception cref="ArgumentException"/> if the enumerated items turns out
/// not to be in increasing order.
/// </summary>
/// <param name="items">The collection to add.</param>
public void AddSorted(SCG.IEnumerable <T> items)
{
//Unless items have <=1 elements we would expect it to be
//too expensive to do repeated inserts, thus:
updatecheck();
int j = 0, i = 0, c = -1, itemcount = countItems(items), numAdded = 0;
SortedArray <T> res = new SortedArray <T>(size + itemcount, _comparer);
T lastitem = default(T);
T[] addedItems = new T[itemcount];
foreach (T item in items)
{
while (i < size && (c = _comparer.Compare(array[i], item)) <= 0)
{
lastitem = res.array[j++] = array[i++];
if (c == 0)
{
goto next;
}
}
if (j > 0 && _comparer.Compare(lastitem, item) >= 0)
{
throw new ArgumentException("Argument not sorted");
}
addedItems[numAdded++] = lastitem = res.array[j++] = item;
next:
c = -1;
}
while (i < size)
{
res.array[j++] = array[i++];
}
size = j;
array = res.array;
raiseForAddAll(addedItems, numAdded);
}
/// <summary>
/// Create a new indexed sorted collection consisting of the results of
/// mapping all items of this list.
/// <exception cref="ArgumentException"/> if the map is not increasing over
/// the items of this collection (with respect to the two given comparison
/// relations).
/// </summary>
/// <param name="m">The delegate definging the map.</param>
/// <param name="c">The comparion relation to use for the result.</param>
/// <returns>The new sorted collection.</returns>
public IIndexedSorted<V> Map<V>(Func<T, V> m, SCG.IComparer<V> c)
{
SortedArray<V> res = new SortedArray<V>(size, c);
if (size > 0)
{
V oldv = res.array[0] = m(array[0]), newv;
for (int i = 1; i < size; i++)
{
if (c.Compare(oldv, newv = res.array[i] = m(array[i])) >= 0)
throw new ArgumentException("mapper not monotonic");
oldv = newv;
}
}
res.size = size;
return res;
}
/// <summary>
/// Create a new indexed sorted collection consisting of the items of this
/// indexed sorted collection satisfying a certain predicate.
/// </summary>
/// <param name="f">The filter delegate defining the predicate.</param>
/// <returns>The new indexed sorted collection.</returns>
public IIndexedSorted<T> FindAll(Func<T, bool> f)
{
SortedArray<T> res = new SortedArray<T>(_comparer);
int j = 0, rescap = res.array.Length;
for (int i = 0; i < size; i++)
{
T a = array[i];
if (f(a))
{
if (j == rescap) res.expand(rescap = 2 * rescap, j);
res.array[j++] = a;
}
}
res.size = j;
return res;
}
public void AddSorted <U>(SCG.IEnumerable <U> items) where U : T
{
//Unless items have <=1 elements we would expect it to be
//too expensive to do repeated inserts, thus:
updatecheck();
int j = 0, i = 0, c = -1, itemcount = EnumerableBase <U> .countItems(items);
SortedArray <T> res = new SortedArray <T>(size + itemcount, comparer);
T lastitem = default(T);
foreach (T item in items)
{
while (i < size && (c = comparer.Compare(array[i], item)) <= 0)
{
lastitem = res.array[j++] = array[i++];
if (c == 0)
{
goto next;
}
}
if (j > 0 && comparer.Compare(lastitem, item) >= 0)
{
throw new ArgumentException("Argument not sorted");
}
lastitem = res.array[j++] = item;
next:
c = -1;
}
while (i < size)
{
res.array[j++] = array[i++];
}
size = j;
array = res.array;
}
/// <summary>
///
/// </summary>
/// <param name="comparer"></param>
/// <param name="equalityComparer"></param>
/// <param name="capacity"></param>
public SortedArrayDictionary(int capacity, SCG.IComparer <K> comparer, SCG.IEqualityComparer <K> equalityComparer)
: base(comparer, equalityComparer)
{
pairs = sortedpairs = new SortedArray <KeyValuePair <K, V> >(capacity, new KeyValuePairComparer <K, V>(comparer));
}
/// <summary>
///
/// </summary>
/// <param name="comparer"></param>
/// <param name="equalityComparer"></param>
public SortedArrayDictionary(System.Collections.Generic.IComparer <K> comparer, System.Collections.Generic.IEqualityComparer <K> equalityComparer)
: base(comparer, equalityComparer)
{
pairs = sortedpairs = new SortedArray <KeyValuePair <K, V> >(new KeyValuePairComparer <K, V>(comparer));
}