public void Adjust(Collection.Node Node, ForEachEnum.AdjustIndexType Type) { if (Node == null || this.mDisposed) { return; } switch (Type) { case ForEachEnum.AdjustIndexType.Insert: if (this.mCurrent == null || Node != this.mCurrent.m_Next) { break; } this.mNext = Node; break; case ForEachEnum.AdjustIndexType.Remove: if (Node == this.mCurrent || Node != this.mNext) { break; } this.mNext = this.mNext.m_Next; break; } }
public bool MoveNext() { if (this.mDisposed) { return(false); } if (this.mAtBeginning) { this.mAtBeginning = false; this.mNext = this.mCollectionObject.GetFirstListNode(); } if (this.mNext == null) { ((IDisposable)this).Dispose(); return(false); } this.mCurrent = this.mNext; if (this.mCurrent != null) { this.mNext = this.mCurrent.m_Next; return(true); } ((IDisposable)this).Dispose(); return(false); }
void IDisposable.Dispose() { if (!this.mDisposed) { this.mCollectionObject.RemoveIterator(this.WeakRef); this.mDisposed = true; } this.mCurrent = (Collection.Node)null; this.mNext = (Collection.Node)null; }
public void Reset() { if (this.mDisposed) { this.mCollectionObject.AddIterator(this.WeakRef); this.mDisposed = false; } this.mCurrent = (Collection.Node)null; this.mNext = (Collection.Node)null; this.mAtBeginning = true; }
void IList.RemoveAt(int index) { Collection.Node RemovedNode = this.m_ItemsList.RemoveAt(index); this.AdjustEnumeratorsOnNodeRemoved(RemovedNode); if (RemovedNode.m_Key != null) { this.m_KeyedNodesHash.Remove(RemovedNode.m_Key); } RemovedNode.m_Prev = (Collection.Node)null; RemovedNode.m_Next = (Collection.Node)null; }
/// <summary>Removes an element from a <see langword="Collection" /> object.</summary> /// <param name="Index">A numeric expression that specifies the position of an element of the collection. <paramref name="Index" /> must be a number from 1 through the value of the collection's <see cref="P:Ported.VisualBasic.Collection.Count" /> property.</param> public void Remove(int Index) { this.IndexCheck(Index); Collection.Node RemovedNode = this.m_ItemsList.RemoveAt(checked (Index - 1)); this.AdjustEnumeratorsOnNodeRemoved(RemovedNode); if (RemovedNode.m_Key != null) { this.m_KeyedNodesHash.Remove(RemovedNode.m_Key); } RemovedNode.m_Prev = (Collection.Node)null; RemovedNode.m_Next = (Collection.Node)null; }
internal void Add(Collection.Node Node) { if (this.m_StartOfList == null) { this.m_StartOfList = Node; } else { this.m_EndOfList.m_Next = Node; Node.m_Prev = this.m_EndOfList; } this.m_EndOfList = Node; checked { ++this.m_Count; } }
internal int IndexOfValue(object Value) { Collection.Node node = this.m_StartOfList; int num = 0; while (node != null) { if (this.DataIsEqual(node.m_Value, Value)) { return(num); } node = node.m_Next; checked { ++num; } } return(-1); }
private void AdjustEnumeratorsHelper(Collection.Node NewOrRemovedNode, ForEachEnum.AdjustIndexType Type) { int index = checked (this.m_Iterators.Count - 1); while (index >= 0) { WeakReference iterator = (WeakReference)this.m_Iterators[index]; if (iterator.IsAlive) { ((ForEachEnum)iterator.Target)?.Adjust(NewOrRemovedNode, Type); } else { this.m_Iterators.RemoveAt(index); } checked { --index; } } }
/// <summary>Returns a specific element of a <see langword="Collection" /> object either by position or by key. Read-only.</summary> /// <param name="Key">A unique <see langword="String" /> expression that specifies a key string that can be used, instead of a positional index, to access an element of the collection. <paramref name="Key" /> must correspond to the <paramref name="Key" /> argument specified when the element was added to the collection.</param> /// <returns>Returns a specific element of a <see langword="Collection" /> object either by position or by key. Read-only.</returns> public object this[string Key] { get { if (Key == null) { throw new IndexOutOfRangeException(Utils.GetResourceString("Argument_CollectionIndex")); } Collection.Node node = (Collection.Node)null; if (!this.m_KeyedNodesHash.TryGetValue(Key, out node)) { throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[1] { "Index" })); } return(node.m_Value); } }
/// <summary>Removes an element from a <see langword="Collection" /> object.</summary> /// <param name="Key">A unique <see langword="String" /> expression that specifies a key string that can be used, instead of a positional index, to access an element of the collection. <paramref name="Key" /> must correspond to the <paramref name="Key" /> argument specified when the element was added to the collection.</param> public void Remove(string Key) { Collection.Node node = (Collection.Node)null; if (this.m_KeyedNodesHash.TryGetValue(Key, out node)) { this.AdjustEnumeratorsOnNodeRemoved(node); this.m_KeyedNodesHash.Remove(Key); this.m_ItemsList.RemoveNode(node); node.m_Prev = (Collection.Node)null; node.m_Next = (Collection.Node)null; } else { throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[1] { nameof(Key) })); } }
internal Collection.Node RemoveAt(int Index) { Collection.Node NodeToBeDeleted = this.m_StartOfList; int num = 0; Collection.Node PrevNode = (Collection.Node)null; while (num < Index && NodeToBeDeleted != null) { PrevNode = NodeToBeDeleted; NodeToBeDeleted = NodeToBeDeleted.m_Next; checked { ++num; } } if (NodeToBeDeleted == null) { throw new ArgumentOutOfRangeException(nameof(Index)); } this.DeleteNode(NodeToBeDeleted, PrevNode); return(NodeToBeDeleted); }
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context) { string[] strArray = new string[checked (this.Count - 1 + 1)]; object[] objArray = new object[checked (this.Count - 1 + 1)]; Collection.Node node = this.GetFirstListNode(); int num = 0; for (; node != null; node = node.m_Next) { if (node.m_Key != null) { checked { ++num; } } int index = 0; strArray[index] = node.m_Key; objArray[index] = node.m_Value; checked { ++index; } } info.AddValue("Keys", (object)strArray, typeof(string[])); info.AddValue("KeysCount", (object)num, typeof(int)); info.AddValue("Values", (object)objArray, typeof(object[])); info.AddValue("CultureInfo", (object)this.m_CultureInfo); }
private void AdjustEnumeratorsOnNodeRemoved(Collection.Node RemovedNode) { this.AdjustEnumeratorsHelper(RemovedNode, ForEachEnum.AdjustIndexType.Remove); }
internal void RemoveNode(Collection.Node NodeToBeDeleted) { this.DeleteNode(NodeToBeDeleted, NodeToBeDeleted.m_Prev); }
private void AdjustEnumeratorsOnNodeInserted(Collection.Node NewNode) { this.AdjustEnumeratorsHelper(NewNode, ForEachEnum.AdjustIndexType.Insert); }
internal void Clear() { this.m_StartOfList = (Collection.Node)null; this.m_EndOfList = (Collection.Node)null; this.m_Count = 0; }
void IList.Insert(int index, object value) { Collection.Node node = new Collection.Node((string)null, value); this.m_ItemsList.Insert(index, node); this.AdjustEnumeratorsOnNodeInserted(node); }
/// <summary>Adds an element to a <see langword="Collection" /> object.</summary> /// <param name="Item">Required. An object of any type that specifies the element to add to the collection.</param> /// <param name="Key">Optional. A unique <see langword="String" /> expression that specifies a key string that can be used instead of a positional index to access this new element in the collection.</param> /// <param name="Before">Optional. An expression that specifies a relative position in the collection. The element to be added is placed in the collection before the element identified by the <paramref name="Before" /> argument. If <paramref name="Before" /> is a numeric expression, it must be a number from 1 through the value of the collection's <see cref="P:Ported.VisualBasic.Collection.Count" /> property. If <paramref name="Before" /> is a <see langword="String" /> expression, it must correspond to the key string specified when the element being referred to was added to the collection. You cannot specify both <paramref name="Before" /> and <paramref name="After" />.</param> /// <param name="After">Optional. An expression that specifies a relative position in the collection. The element to be added is placed in the collection after the element identified by the <paramref name="After" /> argument. If <paramref name="After" /> is a numeric expression, it must be a number from 1 through the value of the collection's <see langword="Count" /> property. If <paramref name="After" /> is a <see langword="String" /> expression, it must correspond to the key string specified when the element referred to was added to the collection. You cannot specify both <paramref name="Before" /> and <paramref name="After" />.</param> public void Add(object Item, string Key = null, object Before = null, object After = null) { if (Before != null && After != null) { throw new ArgumentException(Utils.GetResourceString("Collection_BeforeAfterExclusive")); } Collection.Node node = new Collection.Node(Key, Item); if (Key != null) { try { this.m_KeyedNodesHash.Add(Key, node); } catch (ArgumentException ex) { throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Collection_DuplicateKey")), 457); } } try { if (Before == null && After == null) { this.m_ItemsList.Add(node); } else if (Before != null) { string key = Before as string; if (key != null) { Collection.Node NodeToInsertBefore = (Collection.Node)null; if (!this.m_KeyedNodesHash.TryGetValue(key, out NodeToInsertBefore)) { throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[1] { nameof(Before) })); } this.m_ItemsList.InsertBefore(node, NodeToInsertBefore); } else { this.m_ItemsList.Insert(checked (Conversions.ToInteger(Before) - 1), node); } } else { string key = After as string; if (key != null) { Collection.Node NodeToInsertAfter = (Collection.Node)null; if (!this.m_KeyedNodesHash.TryGetValue(key, out NodeToInsertAfter)) { throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[1] { nameof(After) })); } this.m_ItemsList.InsertAfter(node, NodeToInsertAfter); } else { this.m_ItemsList.Insert(Conversions.ToInteger(After), node); } } } catch (OutOfMemoryException ex) { throw; } catch (ThreadAbortException ex) { throw; } catch (StackOverflowException ex) { throw; } catch (Exception ex) { if (Key != null) { this.m_KeyedNodesHash.Remove(Key); } throw; } this.AdjustEnumeratorsOnNodeInserted(node); }
internal Collection.Node get_Item(int Index) { int Index1 = Index; Collection.Node node = (Collection.Node)null; ref Collection.Node local = ref node;
internal void AdjustOnListCleared() { this.mNext = (Collection.Node)null; }