public SkipLinkedListNode <T> Find(T value) { SkipLinkedListNode <T> node = head; EqualityComparer <T> c = EqualityComparer <T> .Default; if (node != null) { if (value != null) { do { if (c.Equals(node.item, value)) { return(node); } node = node.next; } while (node != head); } else { do { if (node.item == null) { return(node); } node = node.next; } while (node != head); } } return(null); }
public void CopyTo(T[] array, int index) { if (array == null) { throw new ArgumentNullException("array"); } if (index < 0 || index > array.Length) { throw new ArgumentOutOfRangeException("index", $"IndexOutOfRange. Index = {index}"); } if (array.Length - index < Count) { throw new ArgumentException("Arg_InsufficientSpace"); } SkipLinkedListNode <T> node = head; if (node != null) { do { array[index++] = node.item; node = node.next; } while (node != head); } }
public void AddAfter(SkipLinkedListNode <T> node, SkipLinkedListNode <T> newNode) { ValidateNode(node); ValidateNewNode(newNode); InternalInsertNodeBefore(node.next, newNode); newNode.list = this; }
internal Enumerator(SkipLinkedList <T> list) { this.list = list; version = list.version; node = list.head; current = default(T); index = 0; }
public SkipLinkedListNode <T> AddAfter(SkipLinkedListNode <T> node, T value) { ValidateNode(node); SkipLinkedListNode <T> result = new SkipLinkedListNode <T>(node.list, value); InternalInsertNodeBefore(node.next, result); return(result); }
private void InternalInsertNodeBefore(SkipLinkedListNode <T> node, SkipLinkedListNode <T> newNode) { newNode.next = node; newNode.prev = node.prev; node.prev.next = newNode; node.prev = newNode; version++; count++; }
private void InternalInsertNodeToEmptyList(SkipLinkedListNode <T> newNode) { Debug.Assert(head == null && count == 0, "LinkedList must be empty when this method is called!"); newNode.next = newNode; newNode.prev = newNode; head = newNode; version++; count++; }
public bool Remove(T value) { SkipLinkedListNode <T> node = Find(value); if (node != null) { InternalRemoveNode(node); return(true); } return(false); }
public void AddBefore(SkipLinkedListNode <T> node, SkipLinkedListNode <T> newNode) { ValidateNode(node); ValidateNewNode(newNode); InternalInsertNodeBefore(node, newNode); newNode.list = this; if (node == head) { head = newNode; } }
internal void ValidateNewNode(SkipLinkedListNode <T> node) { if (node == null) { throw new ArgumentNullException("node"); } if (node.list != null) { throw new InvalidOperationException("SkipLinkedListNodeIsAttached"); } }
internal void ValidateNode(SkipLinkedListNode <T> node) { if (node == null) { throw new ArgumentNullException("node"); } if (node.list != this) { throw new InvalidOperationException("ExternalSkipLinkedListNode"); } }
public SkipLinkedListNode <T> AddBefore(SkipLinkedListNode <T> node, T value) { ValidateNode(node); SkipLinkedListNode <T> result = new SkipLinkedListNode <T>(node.list, value); InternalInsertNodeBefore(node, result); if (node == head) { head = result; } return(result); }
public SkipLinkedListNode <T> AddLast(T value) { SkipLinkedListNode <T> result = new SkipLinkedListNode <T>(this, value); if (head == null) { InternalInsertNodeToEmptyList(result); } else { InternalInsertNodeBefore(head, result); } return(result); }
public void AddLast(SkipLinkedListNode <T> node) { ValidateNewNode(node); if (head == null) { InternalInsertNodeToEmptyList(node); } else { InternalInsertNodeBefore(head, node); } node.list = this; }
public void Clear() { SkipLinkedListNode <T> current = head; while (current != null) { SkipLinkedListNode <T> temp = current; current = current.Next; // use Next the instead of "next", otherwise it will loop forever temp.Invalidate(); } head = null; count = 0; version++; }
public bool MoveNext() { if (node == null) { index = list.Count + 1; return(false); } ++index; current = node.item; node = node.next; if (node == list.head) { node = null; } return(true); }
public SkipLinkedListNode <T> FindLast(T value) { if (head == null) { return(null); } SkipLinkedListNode <T> last = head.prev; SkipLinkedListNode <T> node = last; EqualityComparer <T> c = EqualityComparer <T> .Default; if (node != null) { if (value != null) { do { if (c.Equals(node.item, value)) { return(node); } node = node.prev; } while (node != last); } else { do { if (node.item == null) { return(node); } node = node.prev; } while (node != last); } } return(null); }
internal void InternalRemoveNode(SkipLinkedListNode <T> node) { Debug.Assert(node.list == this, "Deleting the node from another list!"); Debug.Assert(head != null, "This method shouldn't be called on empty list!"); if (node.next == node) { Debug.Assert(count == 1 && head == node, "this should only be true for a list with only one node"); head = null; } else { node.next.prev = node.prev; node.prev.next = node.next; if (head == node) { head = node.next; } } node.Invalidate(); count--; version++; }
internal void Invalidate() { list = null; next = null; prev = null; }
void System.Collections.IEnumerator.Reset() { current = default(T); node = list.head; index = 0; }
public void Remove(SkipLinkedListNode <T> node) { ValidateNode(node); InternalRemoveNode(node); }
void System.Collections.ICollection.CopyTo(Array array, int index) { if (array == null) { throw new ArgumentNullException("array"); } if (array.Rank != 1) { throw new ArgumentException("Arg_MultiRank"); } if (array.GetLowerBound(0) != 0) { throw new ArgumentException("Arg_NonZeroLowerBound"); } if (index < 0) { throw new ArgumentOutOfRangeException("index", $"IndexOutOfRange. Index = {index}"); } if (array.Length - index < Count) { throw new ArgumentException("Arg_InsufficientSpace"); } T[] tArray = array as T[]; if (tArray != null) { CopyTo(tArray, index); } else { // // Catch the obvious case assignment will fail. // We can found all possible problems by doing the check though. // For example, if the element type of the Array is derived from T, // we can't figure out if we can successfully copy the element beforehand. // Type targetType = array.GetType().GetElementType(); Type sourceType = typeof(T); if (!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType))) { throw new ArgumentException("Invalid_Array_Type"); } object[] objects = array as object[]; if (objects == null) { throw new ArgumentException("Invalid_Array_Type"); } SkipLinkedListNode <T> node = head; try { if (node != null) { do { objects[index++] = node.item; node = node.next; } while (node != head); } } catch (ArrayTypeMismatchException) { throw new ArgumentException("Invalid_Array_Type"); } } }