Trait lock_order::wrap::LockedWrapperApi

pub trait LockedWrapperApi<T, L>: LockedWrapper<T, L>
where
    T: Deref,
    T::Target: Sized,
{
    // Provided methods
    fn lock<'a, M>(&'a mut self) -> <T::Target as LockFor<M>>::Guard<'a>
       where T: 'a,
             T::Target: LockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn lock_and<'a, M>(
        &'a mut self
    ) -> (<T::Target as LockFor<M>>::Guard<'_>, Self::AtLockLevel<'_, M>)
       where T::Target: LockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn lock_with<'a, M, X>(
        &'a mut self,
        f: impl FnOnce(&T::Target) -> &X
    ) -> X::Guard<'a>
       where T: 'a,
             X: LockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn lock_with_and<'a, M, X>(
        &'a mut self,
        f: impl FnOnce(&T::Target) -> &X
    ) -> (X::Guard<'_>, Self::AtLockLevel<'_, M>)
       where X: LockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn read_lock<'a, M>(
        &'a mut self
    ) -> <T::Target as RwLockFor<M>>::ReadGuard<'a>
       where T: 'a,
             T::Target: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn read_lock_and<'a, M>(
        &'a mut self
    ) -> (<T::Target as RwLockFor<M>>::ReadGuard<'_>, Self::AtLockLevel<'_, M>)
       where T::Target: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn read_lock_with<'a, M, X>(
        &'a mut self,
        f: impl FnOnce(&T::Target) -> &X
    ) -> X::ReadGuard<'a>
       where T: 'a,
             X: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn read_lock_with_and<'a, M, X>(
        &'a mut self,
        f: impl FnOnce(&T::Target) -> &X
    ) -> (X::ReadGuard<'_>, Self::AtLockLevel<'_, M>)
       where X: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn write_lock<'a, M>(
        &'a mut self
    ) -> <T::Target as RwLockFor<M>>::WriteGuard<'a>
       where T: 'a,
             T::Target: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn write_lock_and<'a, M>(
        &'a mut self
    ) -> (<T::Target as RwLockFor<M>>::WriteGuard<'_>, Self::AtLockLevel<'_, M>)
       where T::Target: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn write_lock_with<'a, M, X>(
        &'a mut self,
        f: impl FnOnce(&T::Target) -> &X
    ) -> X::WriteGuard<'a>
       where T: 'a,
             X: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn write_lock_with_and<'a, M, X>(
        &'a mut self,
        f: impl FnOnce(&T::Target) -> &X
    ) -> (X::WriteGuard<'_>, Self::AtLockLevel<'_, M>)
       where X: RwLockFor<M>,
             L: LockBefore<M> + 'a { ... }
    fn as_owned(&mut self) -> Self::AtLockLevel<'_, L> { ... }
    fn cast<'a, R>(&'a mut self) -> Self::CastWrapper<&'a R>
       where T: 'a,
             L: 'a,
             T::Target: AsRef<R> { ... }
    fn cast_with<'a, R>(
        &'a mut self,
        f: impl FnOnce(&T::Target) -> &R
    ) -> Self::CastWrapper<&R>
       where T: 'a,
             L: 'a { ... }
    fn cast_locked<'a, M>(&'a mut self) -> Self::AtLockLevel<'_, M>
       where L: LockBefore<M> + 'a { ... }
    fn copied(&self) -> T::Target
       where T::Target: Copy { ... }
    fn adopt<'a, N>(
        &'a mut self,
        n: &'a N
    ) -> Self::CastWrapper<OwnedTupleWrapper<&'a T::Target, &'a N>>
       where T: 'a,
             L: 'a { ... }
    fn cast_left<'a, X, A: Deref + 'a, B: Deref + 'a, F: FnOnce(&A::Target) -> &X>(
        &'a mut self,
        f: F
    ) -> Self::CastWrapper<OwnedTupleWrapper<&X, &B::Target>>
       where L: 'a,
             T: Deref<Target = TupleWrapper<A, B>> + 'a { ... }
    fn cast_right<'a, X, A: Deref + 'a, B: Deref + 'a, F: FnOnce(&B::Target) -> &X>(
        &'a mut self,
        f: F
    ) -> Self::CastWrapper<OwnedTupleWrapper<&A::Target, &X>>
       where L: 'a,
             T: Deref<Target = TupleWrapper<A, B>> + 'a { ... }
}

Provides an API with the same shape as Locked for any type implementing LockedWrapper.

Provided Methods

fn lock<'a, M>(&'a mut self) -> <T::Target as LockFor<M>>::Guard<'a>

where T: 'a, T::Target: LockFor<M>, L: LockBefore<M> + 'a,

Like Locked::lock.

fn lock_and<'a, M>( &'a mut self ) -> (<T::Target as LockFor<M>>::Guard<'_>, Self::AtLockLevel<'_, M>)

where T::Target: LockFor<M>, L: LockBefore<M> + 'a,

Like Locked::lock_and.

fn lock_with<'a, M, X>( &'a mut self, f: impl FnOnce(&T::Target) -> &X ) -> X::Guard<'a>

where T: 'a, X: LockFor<M>, L: LockBefore<M> + 'a,

Like Locked::lock_with.

fn lock_with_and<'a, M, X>( &'a mut self, f: impl FnOnce(&T::Target) -> &X ) -> (X::Guard<'_>, Self::AtLockLevel<'_, M>)

where X: LockFor<M>, L: LockBefore<M> + 'a,

Like Locked::lock_with_and.

fn read_lock<'a, M>(&'a mut self) -> <T::Target as RwLockFor<M>>::ReadGuard<'a>

where T: 'a, T::Target: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::read_lock.

fn read_lock_and<'a, M>( &'a mut self ) -> (<T::Target as RwLockFor<M>>::ReadGuard<'_>, Self::AtLockLevel<'_, M>)

where T::Target: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::read_lock_and.

fn read_lock_with<'a, M, X>( &'a mut self, f: impl FnOnce(&T::Target) -> &X ) -> X::ReadGuard<'a>

where T: 'a, X: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::read_lock_with.

fn read_lock_with_and<'a, M, X>( &'a mut self, f: impl FnOnce(&T::Target) -> &X ) -> (X::ReadGuard<'_>, Self::AtLockLevel<'_, M>)

where X: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::read_lock_with_and.

fn write_lock<'a, M>( &'a mut self ) -> <T::Target as RwLockFor<M>>::WriteGuard<'a>

where T: 'a, T::Target: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::write_lock.

fn write_lock_and<'a, M>( &'a mut self ) -> (<T::Target as RwLockFor<M>>::WriteGuard<'_>, Self::AtLockLevel<'_, M>)

where T::Target: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::write_lock_and.

fn write_lock_with<'a, M, X>( &'a mut self, f: impl FnOnce(&T::Target) -> &X ) -> X::WriteGuard<'a>

where T: 'a, X: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::write_lock_with.

fn write_lock_with_and<'a, M, X>( &'a mut self, f: impl FnOnce(&T::Target) -> &X ) -> (X::WriteGuard<'_>, Self::AtLockLevel<'_, M>)

where X: RwLockFor<M>, L: LockBefore<M> + 'a,

Like Locked::write_lock_with_and.

fn as_owned(&mut self) -> Self::AtLockLevel<'_, L>

Like Locked::as_owned.

fn cast<'a, R>(&'a mut self) -> Self::CastWrapper<&'a R>

where T: 'a, L: 'a, T::Target: AsRef<R>,

Like Locked::cast.

fn cast_with<'a, R>( &'a mut self, f: impl FnOnce(&T::Target) -> &R ) -> Self::CastWrapper<&R>

where T: 'a, L: 'a,

Like Locked::cast_with

fn cast_locked<'a, M>(&'a mut self) -> Self::AtLockLevel<'_, M>

where L: LockBefore<M> + 'a,

Like Locked::cast_locked.

fn copied(&self) -> T::Target

where T::Target: Copy,

Like Locked::copied.

fn adopt<'a, N>( &'a mut self, n: &'a N ) -> Self::CastWrapper<OwnedTupleWrapper<&'a T::Target, &'a N>>

where T: 'a, L: 'a,

Like Locked::adopt.

fn cast_left<'a, X, A: Deref + 'a, B: Deref + 'a, F: FnOnce(&A::Target) -> &X>( &'a mut self, f: F ) -> Self::CastWrapper<OwnedTupleWrapper<&X, &B::Target>>

where L: 'a, T: Deref<Target = TupleWrapper<A, B>> + 'a,

Like Locked::cast_left.

fn cast_right<'a, X, A: Deref + 'a, B: Deref + 'a, F: FnOnce(&B::Target) -> &X>( &'a mut self, f: F ) -> Self::CastWrapper<OwnedTupleWrapper<&A::Target, &X>>

where L: 'a, T: Deref<Target = TupleWrapper<A, B>> + 'a,

Like Locked::cast_right.

Object Safety

This trait is not object safe.

Implementors

impl<T, L, O> LockedWrapperApi<T, L> for O

where T: Deref, T::Target: Sized, O: LockedWrapper<T, L>,