public static void SwitchElems(IListElem <V> elem1, IListElem <V> elem2)
{
V o = elem1.ElemValue;
elem1.ElemValue = elem2.ElemValue;
elem2.ElemValue = o;
}
public void InsertBefore(IListElem <V> insertElem, IListElem <V> beforeElem)
{
if (!ValidateListHandle(beforeElem))
{
throw new Exception("'beforeElem' is not a member of this list");
}
if (ValidateListHandle(insertElem))
{
Remove(insertElem);
}
insertElem.ListHandle = this;
insertElem.Next = beforeElem;
IListElem <V> beforeElemPrev = beforeElem.Prev;
insertElem.Prev = beforeElemPrev;
if (beforeElemPrev != null)
{
beforeElemPrev.Next = insertElem;
}
else
{
anchor.Next = insertElem;
}
beforeElem.Prev = insertElem;
size++;
}
public void InsertAfter(IListElem <V> insertElem, IListElem <V> afterElem)
{
if (!ValidateListHandle(afterElem))
{
throw new Exception("'afterElem' is not a member of this list");
}
if (ValidateListHandle(insertElem))
{
Remove(insertElem);
}
insertElem.ListHandle = this;
insertElem.Prev = afterElem;
IListElem <V> afterElemNext = afterElem.Next;
insertElem.Next = afterElemNext;
if (afterElemNext != null)
{
afterElemNext.Prev = insertElem;
}
else
{
last = insertElem;
}
afterElem.Next = insertElem;
size++;
}
public bool ContainsValue(Object value)
{
IListElem <E> pointer = fastIterationList.First;
if (value == null)
{
while (pointer != null)
{
if (pointer.ElemValue.Value == null)
{
return(true);
}
pointer = pointer.Next;
}
}
else
{
while (pointer != null)
{
if (value.Equals(pointer.ElemValue.Value))
{
return(true);
}
pointer = pointer.Next;
}
}
return(false);
}
public void Remove(IListElem <V> elem)
{
if (!ValidateListHandle(elem))
{
return;
}
IListElem <V> elemPrev = elem.Prev;
IListElem <V> elemNext = elem.Next;
if (elemPrev != null)
{
elemPrev.Next = elemNext;
}
else
{
anchor.Next = elemNext;
}
if (elemNext != null)
{
elemNext.Prev = elemPrev;
}
else
{
last = elemPrev;
}
size--;
CleanRelationToList(elem);
}
protected ClassEntry <V> CopyStructure()
{
ClassEntry <V> newClassEntry = new ClassEntry <V>();
LinkedHashMap <Type, Object> newTypeToDefEntryMap = newClassEntry.typeToDefEntryMap;
LinkedHashMap <StrongKey <V>, List <DefEntry <V> > > newDefinitionReverseMap = newClassEntry.definitionReverseMap;
IdentityHashMap <DefEntry <V>, DefEntry <V> > originalToCopyMap = new IdentityHashMap <DefEntry <V>, DefEntry <V> >();
{
foreach (Entry <Type, Object> entry in classEntry.typeToDefEntryMap)
{
Type key = entry.Key;
Object value = entry.Value;
if (Object.ReferenceEquals(value, alreadyHandled))
{
newTypeToDefEntryMap.Put(key, alreadyHandled);
}
else
{
InterfaceFastList <DefEntry <V> > list = (InterfaceFastList <DefEntry <V> >)value;
InterfaceFastList <DefEntry <V> > newList = new InterfaceFastList <DefEntry <V> >();
IListElem <DefEntry <V> > pointer = list.First;
while (pointer != null)
{
DefEntry <V> defEntry = pointer.ElemValue;
DefEntry <V> newDefEntry = new DefEntry <V>(defEntry.extension, defEntry.type, defEntry.distance);
originalToCopyMap.Put(defEntry, newDefEntry);
newList.PushLast(newDefEntry);
pointer = pointer.Next;
}
newTypeToDefEntryMap.Put(key, newList);
}
TypeToDefEntryMapChanged(newClassEntry, key);
}
}
foreach (Entry <StrongKey <V>, List <DefEntry <V> > > entry in classEntry.definitionReverseMap)
{
List <DefEntry <V> > defEntries = entry.Value;
List <DefEntry <V> > newDefEntries = new List <DefEntry <V> >(defEntries.Count);
for (int a = 0, size = defEntries.Count; a < size; a++)
{
DefEntry <V> newDefEntry = originalToCopyMap.Get(defEntries[a]);
if (newDefEntry == null)
{
throw new Exception("Must never happen");
}
newDefEntries.Add(newDefEntry);
}
newDefinitionReverseMap.Put(entry.Key, newDefEntries);
}
return(newClassEntry);
}
public void ToList(ICollection <K> list)
{
IListElem <E> pointer = fastIterationList.First;
while (pointer != null)
{
list.Add(pointer.ElemValue.Key);
pointer = pointer.Next;
}
}
public void ToList(IList <V> list)
{
IListElem <E> pointer = fastIterationList.First;
while (pointer != null)
{
list.Add(pointer.ElemValue.Value);
pointer = pointer.Next;
}
}
public override IList <V> Values()
{
List <V> list = new List <V>(Count);
IListElem <E> pointer = fastIterationList.First;
while (pointer != null)
{
list.Add(pointer.ElemValue.Value);
pointer = pointer.Next;
}
return(list);
}
public void PushAllFrom(InterfaceFastList <V> list)
{
while (true)
{
IListElem <V> firstElem = list.PopFirst();
if (firstElem == null)
{
return;
}
PushLast(firstElem);
}
}
protected override K[] ToArray(K[] array)
{
int index = 0;
IListElem <E> pointer = fastIterationList.First;
while (pointer != null)
{
array[index++] = pointer.ElemValue.Key;
pointer = pointer.Next;
}
return(array);
}
public override V[] ToArray(V[] targetArray)
{
int index = 0;
IListElem <E> pointer = fastIterationList.First;
while (pointer != null)
{
targetArray[index++] = pointer.ElemValue.Value;
pointer = pointer.Next;
}
return(targetArray);
}
public void PushLast(IListElem <V> elem)
{
if (ValidateListHandle(elem))
{
IListElem <V> elemPrev = elem.Prev;
IListElem <V> elemNext = elem.Next;
if (elemPrev != null)
{
elemPrev.Next = elemNext;
}
else
{
anchor.Next = elemNext;
}
if (elemNext != null)
{
elemNext.Prev = elemPrev;
}
else
{
last = elemPrev;
}
elem.Next = null;
if (size > 0)
{
elem.Prev = last;
last.Next = elem;
}
else
{
elem.Prev = null;
anchor.Next = elem;
}
last = elem;
return;
}
elem.ListHandle = this;
elem.Next = null;
if (size > 0)
{
elem.Prev = last;
last.Next = elem;
}
else
{
elem.Prev = null;
anchor.Next = elem;
}
last = elem;
size++;
}
public void Clear()
{
IListElem <V> pointer = anchor.Next;
anchor.Next = null;
while (pointer != null)
{
IListElem <V> nextPointer = pointer.Next;
CleanRelationToList(pointer);
pointer = nextPointer;
}
size = 0;
last = null;
}
protected bool ValidateListHandle(IListElem <V> elem)
{
Object listHandle = elem.ListHandle;
if (listHandle == null)
{
return(false);
}
if (listHandle != this)
{
throw new Exception("'elem' is not a member of this list");
}
return(true);
}
public void PushFirst(IListElem <V> elem)
{
if (ValidateListHandle(elem))
{
if (size == 1)
{
return;
}
IListElem <V> elemPrev = elem.Prev;
IListElem <V> elemNext = elem.Next;
if (elemPrev != null)
{
elemPrev.Next = elemNext;
}
else
{
anchor.Next = elemNext;
}
if (elemNext != null)
{
elemNext.Prev = elemPrev;
}
else
{
last = elemPrev;
}
IListElem <V> anchorNext = anchor.Next;
elem.Next = anchorNext;
elem.Prev = null;
anchorNext.Prev = elem;
anchor.Next = elem;
return;
}
if (size == 0)
{
PushLast(elem);
}
else
{
elem.ListHandle = this;
IListElem <V> anchorNext = anchor.Next;
elem.Next = anchorNext;
elem.Prev = null;
anchorNext.Prev = elem;
anchor.Next = elem;
size++;
}
}
protected override void Transfer(E[] newTable)
{
int newCapacityMinus1 = newTable.Length - 1;
IListElem <E> pointer = fastIterationList.First, next;
while (pointer != null)
{
next = pointer.Next;
E entry = pointer.ElemValue;
int i = entry.Hash & newCapacityMinus1;
entry.NextEntry = newTable[i];
newTable[i] = entry;
pointer = next;
}
}
public override void Clear()
{
int tableLengthMinusOne = this.tableLengthMinusOne;
IListElem <E> pointer = fastIterationList.First, next;
while (pointer != null)
{
next = pointer.Next;
E entry = pointer.ElemValue;
int i = entry.Hash & tableLengthMinusOne;
table[i] = null;
EntryRemoved(entry);
pointer = next;
}
fastIterationList.Clear();
}
public override void Clear()
{
SetLinkedEntry <K>[] table = this.table;
int tableLengthMinusOne = table.Length - 1;
IListElem <E> entry = fastIterationList.First, next;
while (entry != null)
{
next = entry.Next;
E elem = entry.ElemValue;
int i = GetHashOfEntry(elem) & tableLengthMinusOne;
table[i] = null;
EntryRemoved(elem);
entry = next;
}
fastIterationList.Clear();
}
protected bool AppendRegistration(ConversionKey strongTypeKey, ConversionKey key, V extension, int sourceDistance, int targetDistance,
ClassTupleEntry <V> classEntry)
{
HashMap <ConversionKey, Object> typeToDefEntryMap = classEntry.typeToDefEntryMap;
Object fastList = typeToDefEntryMap.Get(key);
if (fastList != null && fastList != alreadyHandled)
{
IListElem <Def2Entry <V> > pointer = ((InterfaceFastList <Def2Entry <V> >)fastList).First;
while (pointer != null)
{
Def2Entry <V> existingDefEntry = pointer.ElemValue;
if (Object.ReferenceEquals(existingDefEntry.extension, extension) && existingDefEntry.sourceDistance == sourceDistance &&
existingDefEntry.targetDistance == targetDistance)
{
// DefEntry already exists with same distance
return(false);
}
pointer = pointer.Next;
}
}
if (fastList == null || Object.ReferenceEquals(fastList, alreadyHandled))
{
fastList = new InterfaceFastList <Def2Entry <V> >();
typeToDefEntryMap.Put(key, fastList);
}
Def2Entry <V> defEntry = new Def2Entry <V>(extension, key.SourceType, key.TargetType, sourceDistance, targetDistance);
HashMap <Strong2Key <V>, List <Def2Entry <V> > > definitionReverseMap = classEntry.definitionReverseMap;
Strong2Key <V> strongKey = new Strong2Key <V>(extension, strongTypeKey);
List <Def2Entry <V> > typeEntries = definitionReverseMap.Get(strongKey);
if (typeEntries == null)
{
typeEntries = new List <Def2Entry <V> >();
definitionReverseMap.Put(strongKey, typeEntries);
}
typeEntries.Add(defEntry);
InterfaceFastList <Def2Entry <V> > .InsertOrdered((InterfaceFastList <Def2Entry <V> >) fastList, defEntry);
TypeToDefEntryMapChanged(classEntry, key);
return(true);
}
protected override void TypeToDefEntryMapChanged(ClassEntry <V> classEntry, Type key)
{
Object obj = classEntry.typeToDefEntryMap.Get(key);
if (obj == null)
{
classEntry.Remove(key);
return;
}
if (obj == alreadyHandled)
{
classEntry.Put(key, alreadyHandled);
return;
}
Object existingItem = classEntry.Get(key);
List <V> list = (List <V>)(existingItem == alreadyHandled ? null : existingItem);
if (list == null)
{
list = new List <V>();
classEntry.Put(key, list);
}
if (obj is DefEntry <V> )
{
V extension = ((DefEntry <V>)obj).extension;
if (!list.Contains(extension))
{
list.Add(extension);
}
return;
}
IListElem <DefEntry <V> > pointer = ((InterfaceFastList <DefEntry <V> >)obj).First;
while (pointer != null)
{
V extension = pointer.ElemValue.extension;
if (!list.Contains(extension))
{
list.Add(extension);
}
pointer = pointer.Next;
}
}
public static void InsertOrdered <T>(InterfaceFastList <T> list, IListElem <T> elemToInsert) where T : IComparable <T>
{
T value = elemToInsert.ElemValue;
IListElem <T> pointer = list.First;
while (pointer != null)
{
T existingDefEntry = pointer.ElemValue;
if (existingDefEntry.CompareTo(value) < 0)
{
// DefEntry is of higher priority
list.InsertBefore(elemToInsert, pointer);
return;
}
pointer = pointer.Next;
}
// DefEntry is of the least priority
list.PushLast(elemToInsert);
}
protected bool AppendRegistration(Type strongType, Type type, V extension, int distance, ClassEntry <V> classEntry)
{
LinkedHashMap <Type, Object> typeToDefEntryMap = classEntry.typeToDefEntryMap;
Object fastList = typeToDefEntryMap.Get(type);
if (fastList != null && !Object.ReferenceEquals(fastList, alreadyHandled))
{
IListElem <DefEntry <V> > pointer = ((InterfaceFastList <DefEntry <V> >)fastList).First;
while (pointer != null)
{
DefEntry <V> existingDefEntry = pointer.ElemValue;
if (Object.ReferenceEquals(existingDefEntry.extension, extension) && existingDefEntry.distance == distance)
{
// DefEntry already exists with same distance
return(false);
}
pointer = pointer.Next;
}
}
if (fastList == null || Object.ReferenceEquals(fastList, alreadyHandled))
{
fastList = new InterfaceFastList <DefEntry <V> >();
typeToDefEntryMap.Put(type, fastList);
}
DefEntry <V> defEntry = new DefEntry <V>(extension, type, distance);
LinkedHashMap <StrongKey <V>, List <DefEntry <V> > > definitionReverseMap = classEntry.definitionReverseMap;
StrongKey <V> strongKey = new StrongKey <V>(extension, strongType);
List <DefEntry <V> > typeEntries = definitionReverseMap.Get(strongKey);
if (typeEntries == null)
{
typeEntries = new List <DefEntry <V> >();
definitionReverseMap.Put(strongKey, typeEntries);
}
typeEntries.Add(defEntry);
InterfaceFastList <DefEntry <V> > .InsertOrdered((InterfaceFastList <DefEntry <V> >) fastList, defEntry);
TypeToDefEntryMapChanged(classEntry, type);
return(true);
}
public IListElem <V> PopLast()
{
if (size > 0)
{
IListElem <V> elem = last;
IListElem <V> lastPrev = elem.Prev;
if (lastPrev != null)
{
lastPrev.Next = null;
last = lastPrev;
}
else
{
anchor.Next = null;
}
size--;
CleanRelationToList(elem);
return(elem);
}
return(null);
}
public IListElem <V> PopFirst()
{
IListElem <V> anchorNext = anchor.Next;
if (anchorNext != null)
{
IListElem <V> anchorNextNext = anchorNext.Next;
anchor.Next = anchorNextNext;
if (anchorNextNext != null)
{
anchorNextNext.Prev = anchor;
}
else
{
last = null;
}
size--;
CleanRelationToList(anchorNext);
return(anchorNext);
}
return(null);
}
public override bool MoveNext()
{
if (first)
{
IListElem <E> firstElem = fastIterationList.First;
if (firstElem == null)
{
return(false);
}
currEntry = firstElem.ElemValue;
next = currEntry.Next;
first = false;
return(true);
}
else if (next == null)
{
return(false);
}
currEntry = next.ElemValue;
next = currEntry.Next;
return(true);
}
public bool HasListElem(IListElem <V> listElem)
{
return(listElem.ListHandle == this);
}
protected void CleanRelationToList(IListElem <V> listElem)
{
listElem.ListHandle = null;
listElem.Prev = null;
listElem.Next = null;
}
