Struct BucketQueue 

pub struct BucketQueue<T, P, C, Q, Storer>
where
    C: CoarseGrainedPriority<P> + Hash + Ord + Clone,
    P: Ord,
    Q: AbstractPriorityQueue<T, P>,
    Storer: IndexInto<C, Q>,
{ /* private fields */ }

the items of type T and priority P being stored are being stored in one of potentially several Q’s which are all the same kind of AbstractPriorityQueue for such items and priorities but they are divided up by the coarsed grained priority so each one of those are smaller and only storing items with priorities with the same coarse grained priority

Implementations

impl<T, P, C, Q, Storer> BucketQueue<T, P, C, Q, Storer>

where C: CoarseGrainedPriority<P> + Hash + Ord + Clone, P: Ord, Q: AbstractPriorityQueue<T, P>, Storer: IndexInto<C, Q>,

pub fn new( lower_bound_occupied_bucket: C, upper_bound_occupied_bucket: C, dummy: &Q, ) -> Self

pass a lower and upper bound for the coarse grained priorities you are expecting to see these don’t have to be accurate, but if you pass them accurately it is better you also pass an example of Q that is to be used for constructing new buckets

Trait Implementations

impl<T, P, C, Q, Storer> AbstractPriorityQueue<T, P> for BucketQueue<T, P, C, Q, Storer>

where C: CoarseGrainedPriority<P> + Hash + Ord + Clone, P: Ord, Q: AbstractPriorityQueue<T, P>, Storer: IndexInto<C, Q>,

fn empty_copy(&self) -> Self

a version just like self but without any actual items

fn my_peek(&self) -> Option<(&T, &P)>

what would my_dequeue give

fn my_enqueue(&mut self, new_obj: T, new_obj_priority: P)

insert an item with specified priority

fn enqueue_batch( &mut self, new_batch: impl IntoIterator<Item = T>, new_batch_priority: P, )

enqueueing many items all with the same priority, might have a faster implementation than just doing them one by one

fn my_dequeue(&mut self) -> Option<(T, P)>

if nonempty, one item comes out the order is dependent on the specific implementation and how it handles priorities

fn dequeue_batch( &mut self, around_how_many: usize, hard_limit: usize, ) -> Vec<(T, P)>

if there are fewer than around_how_many gives all of the items in the queue if there are more than that, give some number of items that is at least around_how_many but less than or equal to than the hard limit where how much more depends on the specific implementer and the specific items involved

fn my_len(&self) -> usize

how many items are present

fn is_empty(&self) -> bool

is the queue empty

fn enqueue_many(&mut self, new_obj_and_priorities: impl Iterator<Item = (T, P)>)

fn all_items_iter(self) -> impl Iterator<Item = T>

where Self: Sized,

with no more items being enqueue’d we can just dequeue them all and provide an iterator over all the items ignoring their priorities

fn drain_all(&mut self) -> Vec<(T, P)>

dequeue them all but after the mutable reference issues resolved more items can still be enqueue’d unlike all_items_iter which closed this off

impl<T, P, C, Q, Storer> Default for BucketQueue<T, P, C, Q, Storer>

where C: CoarseGrainedPriority<P> + Hash + Ord + Clone + Default, P: Ord, Q: AbstractPriorityQueue<T, P> + Default, Storer: IndexInto<C, Q>,

fn default() -> Self

Returns the “default value” for a type.