Struct phantomdrop::PhantomDrop

pub struct PhantomDrop<T, F: FnOnce(T)>(_);

When dropped, the included function is ran with the argument held by the structure.

Notes

If both the function and the value are zero-sized (unique non-capturing closures are ZSTs), this wrapper will also be zero-sized.

Implementations

impl<F> PhantomDrop<(), F> where
    F: FnOnce(()), 

pub fn defer(fun: F) -> Self

Defer a function to run when this guard is dropped.

impl<T, F> PhantomDrop<T, F> where
    F: FnOnce(T), 

pub fn new(value: T, fun: F) -> Self

Defer a function to run on this stored value when this guard is

pub fn into_inner(self) -> T

Consume the instance into its held type without running the drop closure.

pub fn forget(self)

Consume this instance without running the drop closure.

Notes

This largely has the same behaviour of core::mem::forget, however this method is preferable for instances of PhantomDrop, as it properly calls destructors for both its value and its function if needed.

pub fn as_mut(&mut self) -> &mut T

Get a mutable reference to the held type.

pub fn as_ref(&self) -> &T

Get a reference to the held type.

pub fn neutralise(self) -> PhantomDrop<T, fn(_: T)>

Replace the function to be ran on drop with a no-op.

impl<T: 'static> PhantomDrop<T, Box<dyn FnOnce(T)>>

pub fn boxed(self) -> PhantomDrop<T, Box<dyn FnOnce(T)>>

Box the closure in this instance on to the heap.

pub fn neutralise_boxed(&mut self)

Replace the function to be ran on drop with a no-op in place on the heap.

impl<T> PhantomDrop<T, fn(_: T)>

pub fn neutralise_in_place(&mut self)

Replace the function to be ran on drop with a no-op in place with no allocations.

Trait Implementations

impl<T: Clone, F: Clone + FnOnce(T)> Clone for PhantomDrop<T, F>

pub fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, F: Debug + FnOnce(T)> Debug for PhantomDrop<T, F>

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

Formats the value using the given formatter.

impl<T, F> Drop for PhantomDrop<T, F> where
    F: FnOnce(T), 

pub fn drop(&mut self)

Executes the destructor for this type.