public HashedLinkedListNode<T> AddAfter(HashedLinkedListNode<T> node, T value) { ValidateNode(node); var result = new HashedLinkedListNode<T>(this, value); InsertNodeBefore(node._next, result); return result; }
public void AddAfter(HashedLinkedListNode<T> node, HashedLinkedListNode<T> newNode) { ValidateNode(node); ValidateNewNode(newNode); InsertNodeBefore(node._next, newNode); newNode._list = this; }
private void AddMappingNode(HashedLinkedListNode<T> node) { try { _mappingNodes.Add(node.Value, node); } catch (ArgumentException) { throw new ArgumentException(ErrorMessages.AddingDuplicate); } }
private void ValidateNode(HashedLinkedListNode<T> node) { if (node == null) { throw new ArgumentNullException("node"); } if (node._list != this) { throw new InvalidOperationException(ErrorMessages.ExternalHashedLinkedListNode); } }
private static void ValidateNewNode(HashedLinkedListNode<T> node) { if (node == null) { throw new ArgumentNullException("node"); } if (node._list != null) { throw new InvalidOperationException(ErrorMessages.HashedLinkedListNodeIsAttached); } }
public void AddBefore(HashedLinkedListNode<T> node, HashedLinkedListNode<T> newNode) { ValidateNode(node); ValidateNewNode(newNode); InsertNodeBefore(node, newNode); newNode._list = this; if (node == _head) { _head = newNode; } }
private void InsertNodeBefore(HashedLinkedListNode<T> node, HashedLinkedListNode<T> newNode) { AddMappingNode(newNode); newNode._next = node; newNode._prev = node._prev; node._prev._next = newNode; node._prev = newNode; _version++; _count++; }
public HashedLinkedListNode<T> AddBefore(HashedLinkedListNode<T> node, T value) { ValidateNode(node); var result = new HashedLinkedListNode<T>(this, value); InsertNodeBefore(node, result); if (node == _head) { _head = result; } return result; }
private void InsertNodeToEmptyList(HashedLinkedListNode<T> newNode) { Debug.Assert(_head == null && _count == 0, "The list must be empty when this method is called!"); AddMappingNode(newNode); newNode._next = newNode; newNode._prev = newNode; _head = newNode; _version++; _count++; }
public void Clear() { var current = _head; while (current != null) { var temp = current; current = current.Next; // use Next the instead of "_next", otherwise it will loop forever temp.Invalidate(); } _head = null; _count = 0; _version++; }
public void AddLast(HashedLinkedListNode<T> node) { ValidateNewNode(node); if (_head == null) { InsertNodeToEmptyList(node); } else { InsertNodeBefore(_head, node); } node._list = this; }
public HashedLinkedListNode<T> AddLast(T value) { var result = new HashedLinkedListNode<T>(this, value); if (_head == null) { InsertNodeToEmptyList(result); } else { InsertNodeBefore(_head, result); } return result; }
private void RemoveNode(HashedLinkedListNode<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!"); _mappingNodes.Remove(node.Value); 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; }
public void Remove(HashedLinkedListNode<T> node) { ValidateNode(node); RemoveNode(node); }