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; }