Struct PeekMutGuard

struct PeekMutGuard<'a, T: Ord> {
    peek: Option<PeekMut<'a, T>>,
    unused: &'a mut LinkedList<T>,
}

This is a wrapper for the PeekMut of heap.

Several panics due to future cancellation are caused by calling drop on the PeekMut when futures holding the PeekMut are cancelled and dropped. Dropping a PeekMut will accidentally cause a comparison between the top node and the node below, and may call key() for top node iterators that are in some intermediate inconsistent states.

When a PeekMut is wrapped by this guard, when the guard is dropped, PeekMut::pop will be called on the PeekMut, and the popped node will be added to the linked list that collects the unused nodes. In this way, when the future holding the guard is dropped, the PeekMut will not be called drop, and there will not be unexpected key() called for heap comparison.

In normal usage, when we finished using the PeekMut, we should explicitly call guard.used() in every branch carefully. When we want to pop the PeekMut, we can simply call guard.pop().

Fields

peek: Option<PeekMut<'a, T>>

unused: &'a mut LinkedList<T>

Implementations

impl<'a, T: Ord> PeekMutGuard<'a, T>

fn peek_mut( heap: &'a mut BinaryHeap<T>, unused: &'a mut LinkedList<T>, ) -> Option<Self>

Call peek_mut on the top of heap and return a guard over the PeekMut if the heap is not empty.

fn pop(self) -> T

Call pop on the PeekMut.

fn used(self)

Mark finish using the PeekMut. drop will be called on the PeekMut directly.

Trait Implementations

impl<T: Ord> Deref for PeekMutGuard<'_, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Ord> DerefMut for PeekMutGuard<'_, T>

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

Mutably dereferences the value.

impl<T: Ord> Drop for PeekMutGuard<'_, T>

fn drop(&mut self)

When the guard is dropped, if pop or used is not called before it is dropped, we will call PeekMut::pop on the PeekMut and recycle the node to the unused list.