/// <inheritdoc />
public T DequeueItemFromFront()
{
if (IsEmpty)
{
throw new InvalidOperationException("Unable to Dequeue item from front. Deque is empty");
}
/*
* 1) Get the value from the current head node
* 2) Set the head to the current head's Next node.
* 3) Decrement the count
* 4) Check if the queue contains items, if it does set the new head's
* Previous to null; otherwise both tail and head are nul
*
* */
T item = _head.Value;
_head = _head.Next;
_count--;
if (Count != 0)
{
_head.Previous = null;
}
else
{
_tail = null;
}
_version++;
return(item);
}
/// <inheritdoc />
public T DequeueItemFromBack()
{
if (IsEmpty)
{
throw new InvalidOperationException("Unable to Dequeue item from back. Deque is empty");
}
/*
* 1) Get the value from the current tail node
* 2) Set the tail to the current tail's Previous node.
* 3) Decrement the count
* 4) Check if the queue contains items, if it does set the new tail's
* Next to null; otherwise both tail and head are nul
*
* */
T item = _tail.Value;
_tail = _tail.Previous;
_count--;
if (Count != 0)
{
_tail.Next = null;
}
else
{
_head = null;
}
_version++;
return(item);
}
// ******************************************************************
public void QueueToEnd(T item)
{
bool lockTaken = false;
try
{
_spinLock.Enter(ref lockTaken);
if (_last != null)
{
DequeNode <T> newNode = new DequeNode <T>()
{
Item = item, Previous = _last
};
_last.Next = newNode;
_last = newNode;
}
else
{
_last = new DequeNode <T>()
{
Item = item
};
_first = _last;
}
}
finally
{
if (lockTaken)
{
_spinLock.Exit();
}
}
}
/// <inheritdoc />
public void EnqueueItemToBack(T item)
{
/*
* 1) Create a node to store the item
* 2) Set the node's Previous to point at the current tail
* 3) If there are items in queue set the current tail's Next to the node
* 4) Set the new node as the tail
* 5) Finally check if there is only one item, if so head and tail are the same
* */
DequeNode node = new DequeNode(item);
node.Previous = _tail;
if (Count != 0)
{
_tail.Next = node;
}
_tail = node;
_count++;
if (Count == 1)
{
_head = _tail;
}
_version++;
}
public bool MoveNext()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (_version != _parent._version)
{
throw new InvalidOperationException(
"The Deque was modified after the enumerator was created");
}
if (_currentNode != null)
{
_current = _currentNode.Value;
_currentNode = _currentNode.Next;
_moveResult = true;
}
else
{
_moveResult = false;
}
return(_moveResult);
}
public T PopFront()
{
var result = First;
First = First.Child;
Count--;
return(result.Item);
}
public T PopBack()
{
var result = Last;
Last = Last.Parent;
Count--;
return(result.Item);
}
/// <summary>
/// Removes all items from the <see cref="Deque{T}"/>.
/// </summary>
public void Clear()
{
_count = 0;
_version++;
_head = null;
_tail = null;
}
//--- Constructors ---
internal DequeNode(int capacity, DequeNode next)
{
Data = new T[capacity];
if (next != null)
{
this.Next = next;
next.Prev = this;
}
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="capacity">Maximum number of items in the queue.</param>
public WorkStealingDeque(int capacity)
{
_capacity = capacity;
DequeNode nodeB = new DequeNode(_capacity, null);
DequeNode nodeA = new DequeNode(_capacity, nodeB);
_bottom = new BottomData(nodeA, _capacity - 1);
_top = new TopData(0, nodeA, _capacity - 1);
}
public void DeleteRear()
{
if (this.IsEmpty())
{
return;
}
this.RearNode = this.RearNode.PrevNode;
}
public void DeleteFront()
{
if (this.IsEmpty())
{
return;
}
this.FrontNode = this.FrontNode.NextNode;
}
public void PushFront(T item)
{
if (Count == 0)
{
ZeroPush(item);
}
else
{
First.Parent = new DequeNode <T>(item, null, First);;
First = First.Parent;
}
Count++;
}
public void PushBack(T item)
{
if (Count == 0)
{
ZeroPush(item);
}
else
{
Last.Child = new DequeNode <T>(item, Last, null);
Last = Last.Child;
}
Count++;
}
public void Reset()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (_version != _parent._version)
{
throw new InvalidOperationException(
"The Deque was modified after the enumerator was created");
}
_currentNode = _parent._head;
_moveResult = false;
}
public T PopRight()
{
var current = last;
if (last.Left != null)
{
last.Left.Right = null;
}
else
{
first = null;
}
last = last.Left;
current.Left = null;
N--;
return(current.Item);
}
public T PopLeft()
{
var current = first;
if (first.Right != null)
{
first.Right.Left = null;
}
else
{
last = null;
}
first = first.Right;
current.Right = null;
N--;
return(current.Item);
}
public void PushRight(T item)
{
DequeNode <T> dequeNode = new DequeNode <T>();
dequeNode.Left = last;
if (last != null)
{
last.Right = dequeNode;
}
last = dequeNode;
if (first == null)
{
first = dequeNode;
}
dequeNode.Item = item;
N++;
}
//--- Methods ---
/// <summary>
/// Push an item onto the tail of the queue.
/// </summary>
/// <remarks>
/// NOTE: Push() and TryPop() <strong>MUST</strong> be called from the same thread.
/// </remarks>
/// <param name="data">Item to push onto the tail of the queue.</param>
public void Push(T data)
{
// read bottom data
BottomData curBottom = _bottom;
// write data in current bottom cell
curBottom.Node.Data[curBottom.Index] = data;
BottomData newBottom;
if (curBottom.Index != 0)
{
newBottom = new BottomData(curBottom.Node, curBottom.Index - 1);
}
else
{
// allocate and link a new node
DequeNode newNode = new DequeNode(_capacity, curBottom.Node);
newBottom = new BottomData(newNode, _capacity - 1);
}
// update bottom
_bottom = newBottom;
}
// ******************************************************************
public bool DequeueFromEnd(out T item)
{
bool lockTaken = false;
try
{
_spinLock.Enter(ref lockTaken);
if (_last != null)
{
item = _last.Item;
_last = _last.Previous;
if (_last != null)
{
_last.Next = null;
}
else
{
_first = null;
}
return(true);
}
}
finally
{
if (lockTaken)
{
_spinLock.Exit();
}
}
item = default(T);
return(false);
}
public void InsertFront(T item)
{
if (this.IsEmpty())
{
var nextNode = new DequeNode <T>
{
Data = item,
PrevNode = null,
NextNode = null
};
this.FrontNode = nextNode;
this.RearNode = nextNode;
}
else
{
var nextNode = new DequeNode <T>
{
Data = item,
PrevNode = null,
NextNode = this.FrontNode
};
this.FrontNode = nextNode;
}
}
//--- Constructors ---
internal BottomData(DequeNode node, int index)
{
this.Node = node;
this.Index = index;
}
//--- Constructors ---
internal TopData(int tag, DequeNode node, int index)
{
this.Tag = tag;
this.Node = node;
this.Index = index;
}
private void ZeroPush(T item)
{
First = new DequeNode <T>(item, null, null);
Last = First;
}
public Deque()
{
Count = 0;
First = null;
Last = null;
}
public DequeNode(T i, DequeNode <T> p, DequeNode <T> c)
{
Item = i;
Parent = p;
Child = c;
}
public DequeEnumerator(Deque <T> parent)
{
_parent = parent;
_currentNode = _parent._head;
_version = _parent._version;
}
