Struct guard_trait::MappedMut

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

A mapped guard, which contains a guarded owned pointer, and a mutable 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> MappedMut<T, U> where
    T: GuardedMut,
    U: ?Sized, 

pub fn into_original(self) -> T

Move out the original pointer from the mapped guard, hence cancelling the temporary borrow.

pub fn into_immutable(this: MappedMut<T, U>) -> Mapped<T, U>

Convert MappedMut<T, U> to Mapped<T, U>.

pub fn get_ref(&self) -> &U

Get an immutable reference to the mapped data.

pub fn get_mut(&mut self) -> &mut U

Get a mutable reference to the mapped data.

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

Map the mapped reference again, converting &mut U to &mut V.

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

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

Trait Implementations

impl<T, U> Guarded for MappedMut<T, U> where
    T: GuardedMut,
    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.

impl<T, U> GuardedMut for MappedMut<T, U> where
    T: GuardedMut,
    U: ?Sized, 

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

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