A RollingQueue is a bounded FIFO channel. When the size limit is exceeded, older entries are discarded to make way for newer entries.

Note: if the size limit is less than 1, write will have no effect, and read will always retry.

Create a new, empty RollingQueue, with the given size limit.

To change the size limit later, use setLimit.

IO variant of new. This is useful for creating top-level RollingQueues using unsafePerformIO, because performing atomically inside a pure computation is extremely dangerous (can lead to NestedAtomically errors and even segfaults, see GHC ticket #5866).

Example:

logQueue :: RollingQueue LogEntry
logQueue = unsafePerformIO (RQ.newIO 1000)
{-# NOINLINE logQueue #-}

Write an entry to the rolling queue. If the queue is full, discard the oldest entry.

There is no tryWrite, because write never retries.

Read the next entry from the RollingQueue. retry if the queue is empty.

The Int is the number of entries discarded since the last read operation (usually 0).

Like read, but do not retry. Instead, return Nothing if the queue is empty.

Test if the queue is empty.

O(1) Get the number of items in the queue.

Adjust the size limit. Queue entries will be discarded if necessary to satisfy the new limit.

Get the current size limit. This will return 0 if a negative value was passed to new, newIO, or setLimit.

Verify internal structure. Throw a CheckException if the check fails, signifying a bug in the implementation.

Dump the RollingQueue (output and internal counters) to standard output. This calls checkInvariants first.