Struct ArenaQueue 

pub struct ArenaQueue<N: ArenaQueueNode> { /* private fields */ }

An arena queue - instead of having each node as a separate allocation, a block of memory is allocated for all of the nodes.

The block will never shrink, but will grow to accommodate more slots as needed.

Currently, the amount of slots allocated is always a power of two and is doubled when capacity is exceeded.

If this is an issue, BoxQueue can be used with the box-queue feature flag enabled.

It’s likely easier to use this via the type aliases SingleLinkArenaQueue and DualLinkArenaQueue.

Trait Implementations

impl<N: ArenaQueueNode> ConstDefault for ArenaQueue<N>

Available on crate feature const-default only.

const DEFAULT: Self

The constant default value.

impl<D: ArenaQueueNode> Debug for ArenaQueue<D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<N: ArenaQueueNode> Default for ArenaQueue<N>

fn default() -> Self

Returns the “default value” for a type.

impl<N: ArenaQueueNode> Drop for ArenaQueue<N>

fn drop(&mut self)

Executes the destructor for this type.

impl<N: ArenaQueueNode> PriorityQueue<<N as ArenaQueueNode>::Data> for ArenaQueue<N>

type Handle = ArenaQueueHandle<N>

type SharedHandle = SharedArenaQueueHandle<N>

fn enqueue(&mut self, data: N::Data) -> Self::Handle

Enqueue an entry with provided data. This must return a unique handle for this node.

fn dequeue( &mut self, handle: Self::Handle, ) -> (Option<&N::Data>, Option<Self::SharedHandle>)

Dequeue an entry by its handle

fn get_by_handle(&self, handle: &Self::Handle) -> &N::Data

Get an entry’s data by its handle

fn head_handle(&self) -> Option<Self::SharedHandle>

Get a SharedHandle for the first node in the queue

fn iter_at<'a>( &'a self, after: Option<&Self::Handle>, ) -> impl Iterator<Item = &'a N::Data>

where N::Data: 'a,

Iterate through the queue starting at a provided handle (or None to start with the head node) (including the provided value)

fn update_node( &mut self, handle: &Self::Handle, update: impl FnOnce(&mut N::Data) -> bool, )

Update a node via handle ref. update is a fn that should return true if the node’s priority changed. i.e. if update returns false, the queue does not need to consider repositioning the changed node.

fn get_next_handle(&self, handle: &Self::Handle) -> Option<Self::SharedHandle>

Get the handle for the next node after an input handle (or None if the provided handle is the tail node)

fn iter<'a>(&'a self) -> impl Iterator<Item = &'a P>

where P: 'a,

Iterate through the queue from the start.

fn is_empty(&self) -> bool

Returns true if the queue is empty

fn head(&self) -> Option<&P>

Get the first node in the queue

impl<D: Send + ArenaQueueNode> Send for ArenaQueue<D>

impl<D: Sync + ArenaQueueNode> Sync for ArenaQueue<D>