Struct PeekMut

pub struct PeekMut<'a, T: 'a + Ord, A: Allocator = Global> { pub(in ::collections::binary_heap) heap: &'a mut BinaryHeap<T, A>, pub(in ::collections::binary_heap) original_len: Option<NonZero<usize>> }

Structure wrapping a mutable reference to the greatest item on a BinaryHeap.

This struct is created by the peek_mut method on BinaryHeap. See its documentation for more.

Fields

heap: &'a mut BinaryHeap<T, A>
original_len: Option<NonZero<usize>>

Implementations

impl<'a, T: Ord, A: Allocator> PeekMut<'a, T, A>

fn refresh(&mut self) -> bool

Sifts the current element to its new position.

Afterwards refers to the new element. Returns if the element changed.

Examples

The condition can be used to upper bound all elements in the heap. When only few elements are affected, the heap's sort ensures this is faster than a reconstruction from the raw element list and requires no additional allocation.

#![feature(binary_heap_peek_mut_refresh)]
use std::collections::BinaryHeap;

let mut heap: BinaryHeap<u32> = (0..128).collect();
let mut peek = heap.peek_mut().unwrap();

loop {
    *peek = 99;

    if !peek.refresh() {
        break;
    }
}

// Post condition, this is now an upper bound.
assert!(*peek < 100);

When the element remains the maximum after modification, the peek remains unchanged:

#![feature(binary_heap_peek_mut_refresh)]
use std::collections::BinaryHeap;

let mut heap: BinaryHeap<u32> = [1, 2, 3].into();
let mut peek = heap.peek_mut().unwrap();

assert_eq!(*peek, 3);
*peek = 42;

// When we refresh, the peek is updated to the new maximum.
assert!(!peek.refresh(), "42 is even larger than 3");
assert_eq!(*peek, 42);

fn pop(this: PeekMut<'a, T, A>) -> T

Removes the peeked value from the heap and returns it.

Trait Implementations

impl<T: Ord + Debug, A: Allocator> Debug for PeekMut<'_, T, A>

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

impl<T: Ord, A: Allocator> Deref for PeekMut<'_, T, A>

type Target = T;
fn deref(&self) -> &T

impl<T: Ord, A: Allocator> DerefMut for PeekMut<'_, T, A>

fn deref_mut(&mut self) -> &mut T

impl<T: Ord, A: Allocator> Drop for PeekMut<'_, T, A>

fn drop(&mut self)

Auto Trait Implementations

impl<'a, T, A = Global> !UnwindSafe for PeekMut<'a, T, A>

impl<'a, T, A> Freeze for PeekMut<'a, T, A> where &'a mut BinaryHeap<T, A>: Freeze,

impl<'a, T, A> RefUnwindSafe for PeekMut<'a, T, A> where &'a mut BinaryHeap<T, A>: RefUnwindSafe,

impl<'a, T, A> Send for PeekMut<'a, T, A> where &'a mut BinaryHeap<T, A>: Send,

impl<'a, T, A> Sync for PeekMut<'a, T, A> where &'a mut BinaryHeap<T, A>: Sync,

impl<'a, T, A> Unpin for PeekMut<'a, T, A> where &'a mut BinaryHeap<T, A>: Unpin,

impl<'a, T, A> UnsafeUnpin for PeekMut<'a, T, A> where &'a mut BinaryHeap<T, A>: UnsafeUnpin,

Blanket Implementations

impl<P, T> Receiver for PeekMut<'a, T, A> where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T;

impl<T> Any for PeekMut<'a, T, A> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for PeekMut<'a, T, A> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for PeekMut<'a, T, A> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for PeekMut<'a, T, A>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for PeekMut<'a, T, A> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for PeekMut<'a, T, A>

impl<T, U> Into<U> for PeekMut<'a, T, A> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for PeekMut<'a, T, A> where U: Into<T>,

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for PeekMut<'a, T, A> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>