Struct `PeekMut`

struct PeekMut<'a, T: 'a + Ord, A: Allocator = crate::alloc::Global> { ... }

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.

Implementations

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

fn refresh(self: &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.

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

`impl<'a, T, A> Freeze for PeekMut<'a, T, A>`

`impl<'a, T, A> RefUnwindSafe for PeekMut<'a, T, A>`

`impl<'a, T, A> Send for PeekMut<'a, T, A>`

`impl<'a, T, A> Sync for PeekMut<'a, T, A>`

`impl<'a, T, A> Unpin for PeekMut<'a, T, A>`

`impl<P, T> Receiver for PeekMut<'a, T, A>`

`impl<T> Any for PeekMut<'a, T, A>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for PeekMut<'a, T, A>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for PeekMut<'a, T, A>`

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

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

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for PeekMut<'a, T, A>`

fn into(self: 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 for PeekMut<'a, T, A>`

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

`impl<T, U> TryInto for PeekMut<'a, T, A>`

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

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

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

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

fn deref(self: &Self) -> &T

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

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

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

fn drop(self: &mut Self)