Struct BoxQueue 

pub struct BoxQueue<N: BoxQueueNode> { /* private fields */ }

A queue where nodes are independently allocated via Box.

This is usually much slower than arena queue, but is more memory efficient as the memory used for each node is deallocated once the node is removed.

Usage is only recommended when memory efficiency is needed. If possible, DualLinkBoxQueue should be preferred over SingleLinkBoxQueue, as it almost always faster.

(difference being that DualLinkBoxQueueNode has an extra usize worth of bytes per node)

Trait Implementations

impl<N: BoxQueueNode> ConstDefault for BoxQueue<N>

Available on crate feature const-default only.

const DEFAULT: Self

The constant default value.

impl<N: BoxQueueNode> Default for BoxQueue<N>

fn default() -> Self

Returns the “default value” for a type.

impl<N: BoxQueueNode> PriorityQueue<<N as BoxQueueNode>::Data> for BoxQueue<N>

type Handle = BoxQueueHandle<N>

type SharedHandle = SharedBoxQueueHandle<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 get_by_handle(&self, handle: &Self::Handle) -> &N::Data

Get an entry’s data by its handle

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 dequeue( &mut self, BoxQueueHandle: Self::Handle, ) -> (Option<&N::Data>, Option<Self::SharedHandle>)

Dequeue an entry by its handle

fn is_empty(&self) -> bool

Returns true if the queue is empty

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 head_handle(&self) -> Option<Self::SharedHandle>

Get a SharedHandle for the first node in the queue

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 head(&self) -> Option<&P>

Get the first node in the queue