public void Clear()
{
if (Volatile.Read(ref done))
{
queue.Clear();
}
}
public void OnError(Exception e)
{
q.ForEach(v => v.OnError(e));
q.Clear();
actual.OnError(e);
}
public void TestGrow()
{
ArrayQueue <string> queue = new ArrayQueue <string>(3, 5);
Assert.AreEqual(3, queue.Capacity);
queue.Enqueue("a");
queue.Enqueue("b");
Assert.AreEqual(3, queue.Capacity);
queue.Enqueue("c");
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
{
queue.Enqueue("" + ('d' + i));
}
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
{
queue.Dequeue();
}
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
{
queue.Enqueue("" + ('d' + i));
}
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
{
queue.Dequeue();
}
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
{
queue.Enqueue("" + ('d' + i));
}
Assert.AreEqual(8, queue.Capacity);
queue.Enqueue("z");
Assert.AreEqual(13, queue.Capacity);
queue.Clear();
Assert.AreEqual(13, queue.Capacity);
for (int i = 0; i < 12; i++)
{
queue.Enqueue("" + ('a' + i));
}
Assert.AreEqual(13, queue.Capacity);
queue.Clear();
Assert.AreEqual(13, queue.Capacity);
for (int i = 0; i < 12; i++)
{
queue.Enqueue("" + ('a' + i));
}
Assert.AreEqual(13, queue.Capacity);
}
public void EnqueuingAfterClearingCollection()
{
var stack = new ArrayQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
stack.Enqueue(i);
}
stack.Clear();
for (int i = 0; i < itemCount; i++)
{
stack.Enqueue(i);
}
int trueCount = 0;
int lastItem = int.MinValue;
foreach (var item in stack)
{
if (lastItem > item)
{
Assert.Fail();
}
lastItem = item;
trueCount++;
}
Assert.IsTrue(stack.Count == itemCount &&
stack.Count == trueCount);
}
public void Cancel()
{
Volatile.Write(ref cancelled, true);
upstream.Cancel();
if (Interlocked.Increment(ref wip) == 1)
{
queue.Clear();
}
}
public void OnError(Exception cause)
{
if (done)
{
return;
}
done = true;
queue.Clear();
actual.OnError(cause);
}
public void OnTerminate()
{
if (Interlocked.Decrement(ref active) == 0)
{
upstream.Cancel();
if (!outputFused && Interlocked.Increment(ref wip) == 1)
{
queue.Clear();
}
}
}
public void TestGrow()
{
ArrayQueue<string> queue = new ArrayQueue<string>(3, 5);
Assert.AreEqual(3, queue.Capacity);
queue.Enqueue("a");
queue.Enqueue("b");
Assert.AreEqual(3, queue.Capacity);
queue.Enqueue("c");
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Enqueue("" + ('d' + i));
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Dequeue();
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Enqueue("" + ('d' + i));
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Dequeue();
Assert.AreEqual(8, queue.Capacity);
for (int i = 0; i < 4; i++)
queue.Enqueue("" + ('d' + i));
Assert.AreEqual(8, queue.Capacity);
queue.Enqueue("z");
Assert.AreEqual(13, queue.Capacity);
queue.Clear();
Assert.AreEqual(13, queue.Capacity);
for (int i = 0; i < 12; i++)
queue.Enqueue("" + ('a' + i));
Assert.AreEqual(13, queue.Capacity);
queue.Clear();
Assert.AreEqual(13, queue.Capacity);
for (int i = 0; i < 12; i++)
queue.Enqueue("" + ('a' + i));
Assert.AreEqual(13, queue.Capacity);
}
public void CheckClearQueue()
{
MyQueue <int> queueArray = new ArrayQueue <int>();
MyQueue <int> queueList = new ListQueue <int>();
for (int i = 1; i < 11; i++)
{
queueArray.Enqueue(i);
queueList.Enqueue(i);
}
queueArray.Clear();
queueList.Clear();
Assert.Equal(0, queueArray.Count());
Assert.Equal(0, queueList.Count());
}
/// <summary>
/// Pump all the queued events to the designated handlers. This method should only ever be called from the game thread.
/// </summary>
internal void PumpEvents()
{
// Copy the front buffer to the back buffer before processing.
// It's important to minimize time spend within the lock to avoid stalling other threads trying to enqueue events.
lock (syncRoot)
{
frontBuffer.CopyTo(backBuffer);
frontBuffer.Clear();
}
// The enumerator will preserve the correct queue order.
foreach (Event e in backBuffer)
{
bool processed = false;
// Enumerate through all the registered event dispatchers.
foreach (EventDispatcher dispatcher in eventDispatchers)
{
// If the dispatcher returns true the event has been processed and send to all registered handlers.
if (dispatcher.ProcessEvent(e))
{
processed = true;
break;
}
}
// If no event dispatcher processed the event throw out a warning.
if (!processed)
{
Engine.Log.WriteLine("warning/system", "Event {0} was not processed", e.Type);
}
}
// Clear the back buffer to prevent holding references to otherwise potentially dead instances.
backBuffer.Clear();
}
public void intNumbClear()
{
//arrange
int[] expected_ar = { 0, 0, 0 };
//act
ArrayQueue <int> arr = new ArrayQueue <int>(3);
arr.Enqueue(5);
arr.Enqueue(6);
arr.Enqueue(7);
int[] actual_ar = new int[3];
int i = 0;
arr.Clear();
foreach (var elem in arr)
{
actual_ar[i] = elem;
i++;
}
//assert
CollectionAssert.AreEqual(expected_ar, actual_ar);
}
public void OnComplete()
{
queue.Clear();
actual.OnComplete();
}
public override void OnError(Exception e)
{
lists.Clear();
Error(e);
}
static void Main()
{
var listQueue = new ListQueue <int>();
listQueue.Enqueue(1);
listQueue.Enqueue(3);
listQueue.Enqueue(4);
listQueue.Enqueue(6);
listQueue.Enqueue(9);
DisplayQueue(listQueue);
Console.WriteLine("Добавим в очередь элемент '7'");
listQueue.Enqueue(7);
DisplayItem(listQueue);
listQueue.Clear();
DisplayQueue(listQueue);
var arrayQueue = new ArrayQueue <string>(10);
arrayQueue.Enqueue("1");
arrayQueue.Enqueue("2");
arrayQueue.Enqueue("5");
arrayQueue.Enqueue("6");
arrayQueue.Enqueue("ten");
DisplayQueue(arrayQueue);
Console.WriteLine("Добавим в очередь элемент 'seven'");
arrayQueue.Enqueue("seven");
DisplayItem(arrayQueue);
arrayQueue.Clear();
DisplayQueue(arrayQueue);
var linkedListQueue = new LinkedQueue <int>();
linkedListQueue.Enqueue(1);
linkedListQueue.Enqueue(3);
linkedListQueue.Enqueue(4);
linkedListQueue.Enqueue(6);
linkedListQueue.Enqueue(9);
DisplayQueue(linkedListQueue);
Console.WriteLine("Добавим в очередь элемент '7'");
linkedListQueue.Enqueue(7);
DisplayItem(linkedListQueue);
linkedListQueue.Clear();
DisplayQueue(linkedListQueue);
var listDeque = new ListDeque <int>();
listDeque.AddFirst(1);
listDeque.AddFirst(3);
listDeque.AddFirst(4);
listDeque.AddLast(6);
listDeque.AddLast(9);
DisplayItem(listDeque);
DisplayQueue(listDeque);
Console.WriteLine();
listDeque.AddLast(5);
DisplayItem(listDeque);
Console.WriteLine(listDeque.RemoveFirst());
DisplayItem(listDeque);
var linkedDeque = new LinkedListDeque <int>();
linkedDeque.AddFirst(1);
linkedDeque.AddFirst(3);
linkedDeque.AddFirst(4);
linkedDeque.AddLast(6);
linkedDeque.AddLast(9);
DisplayItem(linkedDeque);
DisplayQueue(linkedDeque);
Console.WriteLine();
linkedDeque.AddLast(5);
DisplayItem(linkedDeque);
Console.WriteLine(linkedDeque.RemoveFirst());
DisplayItem(linkedDeque);
}
public void Clear()
{
_messageQueue.Clear();
}
