RingQueue

RingQueue<T> is a queue that uses internally an array with moving head and tail.

var queue = new RingQueue<int>();

RingQueue.Create(type, initialCount = 32) creates queue with type argument.

var queue =
    (RingQueue<int>)
    RingQueue.Create(typeof(int));

.Enqueue(value) adds value to tail and .Dequeue() removes value from head.

var queue = new RingQueue<int>(capacity: 1);
queue.AllowGrow = true;
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
WriteLine(queue.Capacity); // 11
WriteLine(queue.Dequeue()); // 1
WriteLine(queue.Dequeue()); // 2
WriteLine(queue.Dequeue()); // 3

.AllowGrow policy determines if queue is allowed to grow with .Add() and .Enqueue().

try
{
    var queue = new RingQueue<int>(capacity: 1);
    queue.AllowGrow = false;
    queue.Enqueue(1);
    queue.Enqueue(2); // InvalidOperationException
}
catch (InvalidOperationException)
{
    // Could not grow (AllowGrow = false)
}

.Capacity assigns explicit capacity. .EnsureCapacity(int) ensures specific capacity.

var queue = new RingQueue<int>(capacity: 1);
WriteLine(queue.Capacity); // 1
queue.AllowGrow = false;
queue.Capacity = 10;
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
WriteLine(queue.Capacity); // 10
queue.TrimExcess();
WriteLine(queue.Capacity); // 3
queue.EnsureCapacity(10);
WriteLine(queue.Capacity); // 10

Indexer queue[index] can be used to read and write to queue. Index is relative to head.

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
queue[0] = "AA";
WriteLine(queue.Dequeue()); // AA
WriteLine(queue.Dequeue()); // B
WriteLine(queue.Dequeue()); // C

.SetReadOnly() assigns queue into read-only mode.

var queue = new RingQueue<string>().Enqueue("A").SetReadOnly();

.Skip(int) skips n values at head.

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
queue.Skip(2);
WriteLine(queue.Dequeue()); // C

.Dequeue(int) extracts values from head into an array.

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
string[] array = queue.Dequeue(3); // [ A, B, C ]

.Peek() peeks next value at head. This is same as queue[0].

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
WriteLine(queue.Peek()); // A
WriteLine(queue[0]); // A
WriteLine(queue[1]); // B

.TryPeek(out value) and .TryDequeue(out value) tries to get value if available.

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
if (queue.TryPeek(out string? value0)) WriteLine(value0); // A
if (queue.TryDequeue(out string? value1)) WriteLine(value1); // A

.IndexOf(value, comparer?) finds value from queue.

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
WriteLine(queue.IndexOf("B")); // 1

.BinarySearch(value, comparer) finds value from queue. This requires that values are in sorted order. Binary search is more efficient than IndexOf.

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
WriteLine(queue.BinarySearch("B", StringComparer.Ordinal)); // 1

Queue is IEnumerable<T;>.

var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
foreach (var str in queue) WriteLine(str); // A, B, C

Full Example

Full example

using System;
using Avalanche.Utilities;
using static System.Console;

public class ringqueue
{
    public static void Run()
    {
        {
            // <01>
            var queue = new RingQueue<int>();
            // </01>
        }
        {
            // <02>
            var queue =
                (RingQueue<int>)
                RingQueue.Create(typeof(int));
            // </02>
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            WriteLine(queue.Dequeue()); // 1
            WriteLine(queue.Dequeue()); // 2
            WriteLine(queue.Dequeue()); // 3
        }

        {
            // <03>
            var queue = new RingQueue<int>(capacity: 1);
            queue.AllowGrow = true;
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            WriteLine(queue.Capacity); // 11
            WriteLine(queue.Dequeue()); // 1
            WriteLine(queue.Dequeue()); // 2
            WriteLine(queue.Dequeue()); // 3
            // </03>
        }

        {
            // <04>
            try
            {
                var queue = new RingQueue<int>(capacity: 1);
                queue.AllowGrow = false;
                queue.Enqueue(1);
                queue.Enqueue(2); // InvalidOperationException
            }
            catch (InvalidOperationException)
            {
                // Could not grow (AllowGrow = false)
            }
            // </04>
        }
        {
            // <05>
            var queue = new RingQueue<int>(capacity: 1);
            WriteLine(queue.Capacity); // 1
            queue.AllowGrow = false;
            queue.Capacity = 10;
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            WriteLine(queue.Capacity); // 10
            queue.TrimExcess();
            WriteLine(queue.Capacity); // 3
            queue.EnsureCapacity(10);
            WriteLine(queue.Capacity); // 10
            // </05>
        }

        {
            // <06>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            queue[0] = "AA";
            WriteLine(queue.Dequeue()); // AA
            WriteLine(queue.Dequeue()); // B
            WriteLine(queue.Dequeue()); // C
            // </06>
        }

        {
            // <07>
            var queue = new RingQueue<string>().Enqueue("A").SetReadOnly();
            // </07>
        }

        {
            // <10>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            queue.Skip(2);
            WriteLine(queue.Dequeue()); // C
            // </10>
        }

        {
            // <11>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            string[] array = queue.Dequeue(3); // [ A, B, C ]
            // </11>
        }

        {
            // <12>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            WriteLine(queue.Peek()); // A
            WriteLine(queue[0]); // A
            WriteLine(queue[1]); // B
            // </12>
        }
        {
            // <13>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            if (queue.TryPeek(out string? value0)) WriteLine(value0); // A
            if (queue.TryDequeue(out string? value1)) WriteLine(value1); // A
            // </13>
        }
        {
            // <14>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            WriteLine(queue.IndexOf("B")); // 1
            // </14>
        }
        {
            // <15>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            WriteLine(queue.BinarySearch("B", StringComparer.Ordinal)); // 1
            // </15>
        }
        {
            // <16>
            var queue = new RingQueue<string>().Enqueue("A").Enqueue("B").Enqueue("C");
            foreach (var str in queue) WriteLine(str); // A, B, C
            // </16>
        }

    }
}