Struct Catch 

pub struct Catch<'a, T>(/* private fields */);

A Catch<T> is a Deref/DerefMut wrapper around a T and a F: FnOnce(T) which calls that function on T in place of drop.

This allows you to provide an owned static value with no indirection or locking to somewhere that needs one, and recover the value automatically by a means of your choosing afterwards.

Implementations

impl<'a, T: Send + 'a> Catch<'a, T>

pub fn new(this: T, catch: Box<dyn FnOnce(T) + Send + 'a>) -> Self

Create a new Catch, which will call the function catch on this when it is dropped.

pub fn disarm(Catch: Self) -> (T, Box<dyn FnOnce(T) + 'a>)

Disarm a Catch by unwrapping it into its original T and catch: impl FnOnce(T). If you drop the T now, it will be gone forever – but if you wrap the two together again using Catch::new it will again be caught on drop.

You might use this function if you need owned access to the T itself, but beware: if you’re expecting that the catch function is always called, you need to manually ensure that the Catch is re-assembled or the function called on every code path you care about.

pub fn sync(this: T) -> (Self, impl Fn() -> Option<T>)

Convenience method for the common case when you want to use Catch in a synchronous context, using an internal mutex to hold the caught item.

The returned closure will yield None until the Catch is dropped, and then will yield Some(T) exactly once, before yielding None again forever.

pub fn future(this: T) -> (Self, impl Future<Output = Option<T>> + Send + 'a)

Convenience method for the common case when you want to use Catch in an asynchronous context, using an internal tokio::sync::oneshot to hold the caught item.

The returned future will pend until this is dropped, whereupon it will immediately yield Some(T). If the Catch is disarmed and the catch function dropped, the future will yield None.

Trait Implementations

impl<T: Debug> Debug for Catch<'_, T>

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

Formats the value using the given formatter.

impl<T> Deref for Catch<'_, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Catch<'_, T>

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

Mutably dereferences the value.

impl<T: Future + Unpin> Future for Catch<'_, T>

type Output = <T as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'a, T: Hash> Hash for Catch<'a, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T: Ord> Ord for Catch<'a, T>

fn cmp(&self, other: &Catch<'a, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a, T: PartialEq> PartialEq for Catch<'a, T>

fn eq(&self, other: &Catch<'a, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T: PartialOrd> PartialOrd for Catch<'a, T>

fn partial_cmp(&self, other: &Catch<'a, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, T: Eq> Eq for Catch<'a, T>

impl<'a, T> StructuralPartialEq for Catch<'a, T>