Struct guard_trait::Mapped

pub struct Mapped<T, U> where
    T: Guarded,
    U: ?Sized,  { /* fields omitted */ }

A mapped guard, which contains a guarded owned pointer, and an immutable reference to that pointer. It has had a one-time closure applied to it, but only the output of the closure is stored, not the closure itself. This is similar to how crates like owning_ref work.

Implementations

impl<T, U> Mapped<T, U> where
    T: Guarded,
    U: ?Sized, 

pub fn into_original(self) -> T

Move the inner guarded pointer out from the Mapped wrapper, cancelling the temporary borrow.

pub fn original_by_ref(&self) -> &T

Get the original pointer, by immutable reference.

pub fn get_ref(&self) -> &U

Retrieve an immutable reference to the mapped data.

pub fn and_then<F, V>(self, f: F) -> Mapped<T, V> where
    F: FnOnce(&U) -> &V,
    V: ?Sized, 

Map the mapped wrapper again, converting &U to &V.

pub fn try_and_then<F, V, E>(self, f: F) -> Result<Mapped<T, V>, E> where
    F: FnOnce(&U) -> Result<&V, E>,
    V: ?Sized, 

Attempt to map the reference again, but with the ability to short-circuit on errors.

Trait Implementations

impl<T, U: ?Sized> Debug for Mapped<T, U> where
    T: Guarded,
    U: Debug, 

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

Formats the value using the given formatter.

impl<T, U> Guarded for Mapped<T, U> where
    T: Guarded,
    U: ?Sized, 

type Target = U

The target pointee that this pointer may dereference into. There are no real restrictions to what this type can be. However, the user must not assume that simply because a &Target reference is protected, that references indirectly derived (via Deref and other traits) would also be protected.

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

Borrow the pointee, into a fixed reference that can be sent directly and safely to e.g. memory-sharing completion-based I/O interfaces.