Struct DeferredBucket 

pub struct DeferredBucket<'a, Q, B>
where
    Q: Queue<B>,
    B: Bucket,
{ /* private fields */ }

Implementations

impl<'a, Q, B> DeferredBucket<'a, Q, B>

where Q: Queue<B>, B: Bucket,

pub fn new(queue: &'a mut Q, priority: usize) -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn adding(&mut self) -> &mut B

pub fn removing(&mut self) -> Option<&mut B>

pub fn peeking(&self) -> Option<&B>

pub fn replacing(&mut self) -> &mut B

pub fn replaced(&mut self, old_size: usize, new_size: usize)

Trait Implementations

impl<'a, Q, B> Bucket for DeferredBucket<'a, Q, B>

where Q: Queue<B>, B: Bucket,

type Item = <B as Bucket>::Item

fn new_bucket() -> Self

fn len_bucket(&self) -> usize

fn is_empty_bucket(&self) -> bool

fn clear(&mut self)

impl<'a, Q, B, C> Deferred<C> for DeferredBucket<'a, Q, B>

where Q: Queue<B>, B: Bucket + Queue<C>, C: Bucket,

fn bucket(&mut self, priority: usize) -> DeferredBucket<'_, Self, B>

fn min_bucket(&mut self) -> DeferredBucket<'_, Self, B>

fn max_bucket(&mut self) -> DeferredBucket<'_, Self, B>

impl<'a, Q, B> DoubleEndedBucket for DeferredBucket<'a, Q, B>

where Q: DoubleEndedQueue<B>, B: DoubleEndedBucket,

fn push_back(&mut self, item: Self::Item)

fn push_front(&mut self, item: Self::Item)

fn pop_back(&mut self) -> Option<Self::Item>

fn pop_front(&mut self) -> Option<Self::Item>

impl<'a, Q, B, C> DoubleEndedQueue<C> for DeferredBucket<'a, Q, B>

where Q: Queue<B>, B: Bucket + Queue<C>, C: DoubleEndedBucket,

fn push_back(&mut self, item: B::Item, priority: usize)

fn push_front(&mut self, item: B::Item, priority: usize)

fn pop_back(&mut self, priority: usize) -> Option<B::Item>

fn pop_front(&mut self, priority: usize) -> Option<B::Item>

fn pop_back_min(&mut self) -> Option<B::Item>

fn pop_front_min(&mut self) -> Option<B::Item>

fn pop_back_max(&mut self) -> Option<B::Item>

fn pop_front_max(&mut self) -> Option<B::Item>

impl<'a, Q, B> FirstInFirstOutBucket for DeferredBucket<'a, Q, B>

where Q: FirstInFirstOutQueue<B>, B: FirstInFirstOutBucket,

fn enqueue(&mut self, item: Self::Item)

fn dequeue(&mut self) -> Option<Self::Item>

impl<'a, Q, B, C> FirstInFirstOutQueue<C> for DeferredBucket<'a, Q, B>

where Q: Queue<B>, B: Bucket + Queue<C>, C: FirstInFirstOutBucket,

fn enqueue(&mut self, item: B::Item, priority: usize)

fn dequeue(&mut self, priority: usize) -> Option<B::Item>

fn dequeue_min(&mut self) -> Option<B::Item>

fn dequeue_max(&mut self) -> Option<B::Item>

impl<'a, Q, B> LastInFirstOutBucket for DeferredBucket<'a, Q, B>

where Q: LastInFirstOutQueue<B>, B: LastInFirstOutBucket,

fn push(&mut self, item: Self::Item)

fn pop(&mut self) -> Option<Self::Item>

impl<'a, Q, B, C> LastInFirstOutQueue<C> for DeferredBucket<'a, Q, B>

where Q: Queue<B>, B: Bucket + Queue<C>, C: LastInFirstOutBucket,

fn push(&mut self, item: B::Item, priority: usize)

fn pop(&mut self, priority: usize) -> Option<B::Item>

fn pop_min(&mut self) -> Option<B::Item>

fn pop_max(&mut self) -> Option<B::Item>

impl<'a, Q, B, C> Queue<C> for DeferredBucket<'a, Q, B>

where Q: Queue<B>, B: Bucket + Queue<C>, C: Bucket,

fn new_queue() -> Self

fn min_priority(&self) -> Option<usize>

fn max_priority(&self) -> Option<usize>

fn bucket_for_adding(&mut self, priority: usize) -> &mut C

fn bucket_for_removing(&mut self, priority: usize) -> Option<&mut C>

fn bucket_for_peeking(&self, priority: usize) -> Option<&C>

fn bucket_for_replacing(&mut self, priority: usize) -> &mut Option<C>

fn items_replaced(&mut self, priority: usize, old_size: usize, new_size: usize)

fn len_queue(&self) -> usize

fn is_empty_queue(&self) -> bool

fn replace(&mut self, priority: usize, replacement: Option<C>) -> Option<C>