Trait LockedWrapper

pub trait LockedWrapper<T, L>
where
    T: Deref,
{
    type AtLockLevel<'l, M>: LockedWrapper<&'l T::Target, M>
       where M: 'l,
             T: 'l;
    type CastWrapper<X>: LockedWrapper<X, L>
       where X: Deref,
             X::Target: Sized;

    // Required methods
    fn wrap<'l, M>(locked: Locked<&'l T::Target, M>) -> Self::AtLockLevel<'l, M>
       where M: 'l,
             T: 'l;
    fn wrap_cast<R: Deref>(locked: Locked<R, L>) -> Self::CastWrapper<R>
       where R::Target: Sized;
    fn get_mut(&mut self) -> &mut Locked<T, L>;
    fn get(&self) -> &Locked<T, L>;
}

A trait implemented by newtypes on Locked

Required Associated Types

type AtLockLevel<'l, M>: LockedWrapper<&'l T::Target, M> where M: 'l, T: 'l

The same wrapper at a different lock level.

type CastWrapper<X>: LockedWrapper<X, L> where X: Deref, X::Target: Sized

The same wrapper with a different locked state.

Required Methods

fn wrap<'l, M>(locked: Locked<&'l T::Target, M>) -> Self::AtLockLevel<'l, M>

where M: 'l, T: 'l,

Wraps Locked into a newtype.

fn wrap_cast<R: Deref>(locked: Locked<R, L>) -> Self::CastWrapper<R>

where R::Target: Sized,

Wraps a Locked into a different wrapper implementation.

fn get_mut(&mut self) -> &mut Locked<T, L>

Gets a mutable reference to the wrapped Locked.

fn get(&self) -> &Locked<T, L>

Gets an immutable reference to the wrapped Locked.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, L> LockedWrapper<T, L> for Locked<T, L>

where T: Deref, T::Target: Sized,

type AtLockLevel<'l, M> = Locked<&'l <T as Deref>::Target, M> where M: 'l, T: 'l

type CastWrapper<X> = Locked<X, L> where X: Deref, X::Target: Sized