public void Insert(k_Iterator ak_Where, k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
{
int li_FirstIndex = ((k_BlockIterator)ak_Where).Index;
int li_Count = ak_SrcEnd - ak_SrcBegin;
if (mk_Blocks.Length * mi_BlockSize <= mi_Count + li_Count + mi_BlockSize)
{
AllocateBlock(li_Count);
}
mi_Count += li_Count;
k_Iterator lk_Dest;
if (li_FirstIndex < li_Count / 2)
{
if (mi_Offset == 0)
{
mi_Offset = mk_Blocks.Length * mi_BlockSize;
}
mi_Offset -= li_Count;
lk_Dest = k_Algorithm.Copy(this.Begin + li_Count, this.Begin + li_FirstIndex + li_Count, this.Begin);
}
else
{
// count has been incremented - there are li_Count free elements at the end
lk_Dest = this.Begin + li_FirstIndex;
k_Algorithm.CopyBackward(lk_Dest, this.End - li_Count, this.End);
}
k_Algorithm.Copy(ak_SrcBegin, ak_SrcEnd, lk_Dest);
}
public static void Fill(k_Iterator ak_DstFirst, k_Iterator ak_BehindDstLast, object ak_Value)
{
for (k_Iterator lk_Iter = ak_DstFirst.Clone(); lk_Iter != ak_BehindDstLast; lk_Iter.Next())
{
lk_Iter.Current = ak_Value;
}
}
public k_HashTable(int ai_Capacity, double ad_LoadFactor, IHashCodeProvider ak_HashProvider, IComparer ak_Comparer)
{
if (ad_LoadFactor <= .0 || ad_LoadFactor > 1.0)
{
throw new ArgumentException("Load factor must be greater than .0 and smaller or equal to 1.0", "ad_LoadFactor");
}
md_LoadFactor = ad_LoadFactor;
double ld_Size = ai_Capacity / ad_LoadFactor;
if (ld_Size > int.MaxValue)
{
throw new ArgumentException("k_HashTable overflow");
}
int li_TableSize = FindPrimeGreater((int)ld_Size);
mk_Buckets = new r_Bucket[li_TableSize];
mi_GrowSize = (md_LoadFactor < 1.0) ? (int)(md_LoadFactor * li_TableSize) : li_TableSize - 1;
mk_HashProvider = ak_HashProvider;
mk_Comparer = ak_Comparer;
mk_End = new k_PinnedBucketIterator(this, -1);
}
public void Insert(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
{
for (k_Iterator lk_Iter = ak_SrcBegin.Clone(); lk_Iter != ak_SrcEnd; lk_Iter.Next())
{
Add((DictionaryEntry)lk_Iter.Current);
}
}
public void CopyTo(Array ak_Array, int ai_Index)
{
for (k_Iterator lk_Iter = mk_Items.Begin.Clone(); lk_Iter != mk_Items.End; lk_Iter.Next())
{
ak_Array.SetValue(lk_Iter.Current, ai_Index++);
}
}
public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
{
if (ak_First == ak_Last)
{
return(ak_Last);
}
int li_FirstIndex = ((k_BlockIterator)ak_First).Index;
int li_Count = ak_Last - ak_First;
int li_LastCount = this.End - ak_Last;
if (li_FirstIndex < li_LastCount)
{
k_Algorithm.CopyBackward(this.Begin, ak_First, ak_Last);
k_Algorithm.Fill(this.Begin, ak_First, null);
mi_Offset += li_Count;
mi_Offset %= (mk_Blocks.Length * mi_BlockSize);
}
else
{
k_Algorithm.Copy(ak_Last, this.End, ak_First);
k_Algorithm.Fill(ak_Last, this.End, null);
}
mi_Count -= li_Count;
return(new k_BlockIterator(this, li_FirstIndex));
}
private void PasteNodeRange(k_NodeIterator ak_Where, k_Node ak_First, k_Node ak_Last)
{
if (ak_Where != this.End)
{
k_Node lk_Next = ak_Where.Node;
k_Node lk_Prev = lk_Next.mk_Prev;
ak_Last.mk_Next = lk_Next;
ak_First.mk_Prev = lk_Prev;
if (lk_Next != null)
{
lk_Next.mk_Prev = ak_Last;
}
if (lk_Prev != null)
{
lk_Prev.mk_Next = ak_First;
}
}
else
{
if (mk_Tail != null)
{
mk_Tail.mk_Next = ak_First;
ak_First.mk_Prev = mk_Tail;
}
mk_Tail = ak_Last;
}
if (ak_Where == this.Begin)
{
mk_Head = ak_First;
mk_Begin = null; // recalc on next get
}
}
public k_Iterator Erase(k_Iterator ak_Where)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this tree.");
k_Iterator lk_Successor = ak_Where + 1;
RemoveNode(((k_NodeIterator)ak_Where).Node);
return(lk_Successor);
}
public k_Iterator Erase(k_Iterator ak_Where)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
k_Iterator lk_Successor = ak_Where + 1;
EmptyBucket(((k_BucketIterator)ak_Where).Index);
return(lk_Successor);
}
public void Insert(k_Iterator ak_Where, object ak_Value, int ai_Count)
{
int li_Pos = ((k_IListIterator)ak_Where).Index;
for (int i = 0; i < ai_Count; ++i)
{
base.Insert(li_Pos + i, ak_Value);
}
}
public void Insert(k_Iterator ak_Where, object ak_Value)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
k_Node lk_New = new k_Node(ak_Value);
PasteNodeRange((k_NodeIterator)ak_Where, lk_New, lk_New);
++mi_Count;
}
public k_Iterator Erase(k_Iterator ak_Where)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this list.");
if (ak_Where == this.End)
{
return(this.End);
}
return(Erase(ak_Where, ak_Where + 1));
}
public int IndexOf(object ak_Value)
{
k_Iterator lk_Found = Find(ak_Value);
if (lk_Found == this.End)
{
return(-1);
}
return(((k_BlockIterator)lk_Found).Index);
}
public object Clone()
{
k_List lk_Clone = new k_List();
for (k_Iterator lk_Iter = this.Begin.Clone(); lk_Iter != this.End; lk_Iter.Next())
{
lk_Clone.Add(lk_Iter.Current);
}
return(lk_Clone);
}
public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_First.Collection) && object.ReferenceEquals(this, ak_Last.Collection), "Iterators do not belong to this collection.");
int li_FirstIndex = ((k_IListIterator)ak_First).Index;
int li_Count = ak_Last - ak_First;
base.RemoveRange(li_FirstIndex, li_Count);
return(new k_IListIterator(this, li_FirstIndex));
}
public override int Distance(k_Iterator ak_Iter)
{
k_NodeIterator lk_Iter = ak_Iter as k_NodeIterator;
if (lk_Iter == null || !object.ReferenceEquals(lk_Iter.Collection, this.Collection))
{
throw new ArgumentException("Cannot determine distance of iterators belonging to different collections.");
}
k_Iterator lk_End = mk_Tree.End;
int li_KeyDiff;
if (this == lk_End || ak_Iter == lk_End)
{
li_KeyDiff = (this == lk_End && this != ak_Iter) ? 1 : 0;
}
else
{
li_KeyDiff = mk_Tree.mk_Comparer.Compare(mk_Current.Key, lk_Iter.mk_Current.Key);
}
if (li_KeyDiff <= 0)
{
int li_Diff = 0;
k_Iterator lk_Bck = this.Clone();
for (; lk_Bck != ak_Iter && lk_Bck != lk_End; lk_Bck.Next())
{
--li_Diff;
}
if (lk_Bck == ak_Iter)
{
return(li_Diff);
}
}
if (li_KeyDiff >= 0)
{
int li_Diff = 0;
k_Iterator lk_Fwd = ak_Iter.Clone();
for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
{
++li_Diff;
}
if (lk_Fwd == this)
{
return(li_Diff);
}
}
throw new Exception("Inconsistent state. Concurrency?");
}
public k_Iterator Erase(k_Iterator ak_Where)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
int li_Index = ((k_IListIterator)ak_Where).Index;
if (li_Index < this.Count)
{
base.RemoveAt(li_Index);
}
return(new k_IListIterator(this, li_Index));
}
public static k_Iterator CopyBackward(k_Iterator ak_SrcFirst, k_Iterator ak_BehindSrcLast, k_Iterator ak_BehindDstLast)
{
k_Iterator lk_Src = ak_BehindSrcLast.Clone(), lk_Dst = ak_BehindDstLast.Clone();
while (lk_Src != ak_SrcFirst)
{
lk_Src.Prev(); lk_Dst.Prev();
lk_Dst.Current = lk_Src.Current;
}
return(lk_Dst);
}
public static k_Iterator Copy(k_Iterator ak_SrcFirst, k_Iterator ak_BehindSrcLast, k_Iterator ak_DstFirst)
{
k_Iterator lk_Src = ak_SrcFirst.Clone(), lk_Dst = ak_DstFirst.Clone();
while (lk_Src != ak_BehindSrcLast)
{
lk_Dst.Current = lk_Src.Current;
lk_Src.Next(); lk_Dst.Next();
}
return(lk_Dst);
}
public k_SkipList(IComparer ak_Comparer, double ad_Prob, int ai_MaxLevel)
{
if (ad_Prob >= 1.0 || ad_Prob <= 0)
{
throw new ArgumentException("Invalid probability. Must be (0-1).", "ad_Prob");
}
md_Prob = ad_Prob;
mi_MaxLevel = ai_MaxLevel;
mk_Comparer = ak_Comparer;
mk_Head = new k_Node(null, null, ai_MaxLevel);
mk_End = new k_PinnedNodeIterator(this, null);
}
public override int Distance(k_Iterator ak_Iter)
{
k_BucketIterator lk_Iter = ak_Iter as k_BucketIterator;
if (lk_Iter == null || !object.ReferenceEquals(lk_Iter.Collection, this.Collection))
{
throw new ArgumentException("Cannot determine distance of iterators belonging to different collections.");
}
k_Iterator lk_End = mk_Table.End;
int li_IndexDiff;
if (this != lk_End && ak_Iter != lk_End)
{
li_IndexDiff = mi_Index - lk_Iter.mi_Index;
}
else
{
li_IndexDiff = (this == lk_End) ? 1 : -1; // 1 is also fine when both are End
}
if (li_IndexDiff < 0)
{
int li_Diff = 0;
k_Iterator lk_Bck = this.Clone();
for (; lk_Bck != ak_Iter && lk_Bck != lk_End; lk_Bck.Next())
{
--li_Diff;
}
if (lk_Bck == ak_Iter)
{
return(li_Diff);
}
}
else
{
int li_Diff = 0;
k_Iterator lk_Fwd = ak_Iter.Clone();
for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
{
++li_Diff;
}
if (lk_Fwd == this)
{
return(li_Diff);
}
}
throw new Exception("Inconsistent state. Concurrency?");
}
public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_First.Collection) && object.ReferenceEquals(this, ak_Last.Collection), "Iterators do not belong to this collection.");
int li_Distance = ak_Last - ak_First;
if (li_Distance == 0)
{
return(ak_Last);
}
k_Node lk_First = ((k_NodeIterator)ak_First).Node;
k_Node lk_Prev = lk_First.mk_Prev;
k_Node lk_Next = (ak_Last != this.End) ? ((k_NodeIterator)ak_Last).Node : null;
if (lk_Prev != null)
{
lk_Prev.mk_Next = lk_Next;
}
else
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(mk_Head, lk_First), "Inconsistent list state");
mk_Head = lk_Next;
mk_Begin = null;
}
if (lk_Next != null)
{
lk_Next.mk_Prev = lk_Prev;
}
else
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(mk_Tail, ((k_NodeIterator)(ak_Last-1)).Node), "Inconsistent list state");
mk_Tail = lk_Prev;
}
mi_Count -= li_Distance;
#if (DEBUG)
// create invalid nodes linking to itself
k_Node lk_Node = lk_First;
while (lk_Node != null && lk_Node != lk_Next)
{
k_Node lk_Tmp = lk_Node.mk_Next;
lk_Node.mk_Next = lk_Node;
lk_Node.mk_Prev = lk_Node;
lk_Node = lk_Tmp;
}
#endif
return(ak_Last);
}
public object this[int index]
{
get
{
k_Iterator lk_Iter = this.Begin + index;
return(lk_Iter.Current);
}
set
{
k_Iterator lk_Iter = this.Begin + index;
lk_Iter.Current = value;
}
}
public static k_Iterator Find(k_Iterator ak_First, k_Iterator ak_Last, object ak_Value)
{
k_Iterator lk_Iter = ak_First.Clone();
for (; lk_Iter != ak_Last; lk_Iter.Next())
{
if (object.Equals(lk_Iter.Current, ak_Value))
{
break;
}
}
return(lk_Iter);
}
public override int Distance(k_Iterator ak_Iter)
{
k_NodeIterator lk_Iter = (k_NodeIterator)ak_Iter;
k_Iterator lk_End = mk_List.End;
int li_KeyDiff;
if (this == lk_End || ak_Iter == lk_End)
{
li_KeyDiff = (this == lk_End && this != ak_Iter) ? 1 : 0;
}
else
{
li_KeyDiff = mk_List.mk_Comparer.Compare(mk_Current.Key, lk_Iter.mk_Current.Key);
}
if (li_KeyDiff <= 0)
{
int li_Diff = 0;
k_Iterator lk_Bck = this.Clone();
for (; lk_Bck != lk_Iter && lk_Bck != lk_End; lk_Bck.Next())
{
--li_Diff;
}
if (lk_Bck == lk_Iter)
{
return(li_Diff);
}
}
if (li_KeyDiff >= 0)
{
int li_Diff = 0;
k_Iterator lk_Fwd = lk_Iter.Clone();
for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
{
++li_Diff;
}
if (lk_Fwd == this)
{
return(li_Diff);
}
}
throw new Exception("Inconsistent state. Concurrency?");
}
public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
{
if (ak_First == this.Begin && ak_Last == this.End)
{
Clear();
return(ak_Last.Clone());
}
k_Iterator lk_Current = ak_First;
while (lk_Current != ak_Last)
{
lk_Current = Erase(lk_Current);
}
return(lk_Current);
}
public void Insert(k_Iterator ak_Where, object ak_Value, int ai_Count)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
k_Node lk_Start = new k_Node(null), lk_End = lk_Start;
for (int i = 0; i < ai_Count; ++i)
{
k_Node lk_New = new k_Node(ak_Value);
lk_End.mk_Next = lk_New;
lk_New.mk_Prev = lk_End;
lk_End = lk_New;
}
if (ai_Count > 0)
{
PasteNodeRange((k_NodeIterator)ak_Where, lk_Start.mk_Next, lk_End);
mi_Count += ai_Count;
}
}
public void Insert(k_Iterator ak_Where, k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
{
//System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
k_Node lk_Start = new k_Node(null), lk_End = lk_Start;
int li_Count = 0;
for (k_Iterator lk_Iter = ak_SrcBegin.Clone(); lk_Iter != ak_SrcEnd; lk_Iter.Next(), ++li_Count)
{
k_Node lk_New = new k_Node(lk_Iter.Current);
lk_End.mk_Next = lk_New;
lk_New.mk_Prev = lk_End;
lk_End = lk_New;
}
if (li_Count > 0)
{
PasteNodeRange((k_NodeIterator)ak_Where, lk_Start.mk_Next, lk_End);
mi_Count += li_Count;
}
}
public void Insert(k_Iterator ak_Where, object ak_Value)
{
if (ak_Where == this.Begin)
{
PushFront(ak_Value);
}
else if (ak_Where == this.End)
{
PushBack(ak_Value);
}
else
{
int li_Index = ((k_BlockIterator)ak_Where).Index;
if (mk_Blocks.Length * mi_BlockSize - mi_Count < mi_BlockSize)
{
AllocateBlock(mi_BlockSize);
}
++mi_Count;
if (li_Index < mi_Count / 2)
{
if (mi_Offset == 0)
{
mi_Offset = mk_Blocks.Length * mi_BlockSize;
}
--mi_Offset;
k_Iterator lk_Dest = k_Algorithm.Copy(this.Begin + 1, this.Begin + li_Index + 1, this.Begin);
lk_Dest.Current = ak_Value;
}
else
{
// count has been incremented - there is a free element at the end
k_Iterator lk_Dest = this.Begin + li_Index;
k_Algorithm.CopyBackward(lk_Dest, this.End - 1, this.End);
lk_Dest.Current = ak_Value;
}
}
}
public override int Distance(k_Iterator ak_Iter)
{
k_NodeIterator lk_Iter = (k_NodeIterator)ak_Iter;
if (!this.IsValid || !lk_Iter.IsValid)
{
throw new ArgumentException("Iterator is invalid.");
}
int li_Diff = 0;
k_Iterator lk_End = mk_List.End;
k_Iterator lk_Fwd = lk_Iter.Clone();
for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
{
++li_Diff;
}
if (lk_Fwd == this)
{
return(li_Diff);
}
li_Diff = 0;
k_Iterator lk_Bck = this.Clone();
for (; lk_Bck != lk_Iter && lk_Bck != lk_End; lk_Bck.Next())
{
--li_Diff;
}
if (lk_Bck == lk_Iter)
{
return(li_Diff);
}
throw new Exception("Inconsistent state. Concurrency?");
}
