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