Struct AsyncLockKpThenLockKp 

pub struct AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, First, Second> { /* private fields */ }

Keypath that goes through an async lock then a sync crate::lock::LockKp. Use AsyncLockKp::then_lock to create; then call AsyncLockKpThenLockKp::get or AsyncLockKpThenLockKp::get_mut with root.

Implementations

impl<R, V2, Root, Value2, MutRoot, MutValue2, Lock, Mid, V, LockValue, MidValue, Value, MutLock, MutMid, MutValue, G1, S1, L, G2, S2, Lock2, Mid2, LockValue2, MidValue2, MutLock2, MutMid2, G2_1, S2_1, L2, G2_2, S2_2> AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, AsyncLockKp<R, Lock, Mid, V, Root, LockValue, MidValue, Value, MutRoot, MutLock, MutMid, MutValue, G1, S1, L, G2, S2>, LockKp<V, Lock2, Mid2, V2, Value, LockValue2, MidValue2, Value2, MutValue, MutLock2, MutMid2, MutValue2, G2_1, S2_1, L2, G2_2, S2_2>>

where Root: Borrow<R>, LockValue: Borrow<Lock>, MidValue: Borrow<Mid>, Value: Borrow<V>, MutRoot: BorrowMut<R>, MutLock: BorrowMut<Lock>, MutMid: BorrowMut<Mid>, MutValue: BorrowMut<V>, Value2: Borrow<V2>, MutValue2: BorrowMut<V2>, G1: Fn(Root) -> Option<LockValue> + Clone, S1: Fn(MutRoot) -> Option<MutLock> + Clone, L: AsyncLockLike<Lock, MidValue> + AsyncLockLike<Lock, MutMid> + Clone, G2: Fn(MidValue) -> Option<Value> + Clone, S2: Fn(MutMid) -> Option<MutValue> + Clone, LockValue2: Borrow<Lock2>, MidValue2: Borrow<Mid2>, MutLock2: BorrowMut<Lock2>, MutMid2: BorrowMut<Mid2>, G2_1: Fn(Value) -> Option<LockValue2>, S2_1: Fn(MutValue) -> Option<MutLock2>, L2: LockAccess<Lock2, MidValue2> + LockAccess<Lock2, MutMid2>, G2_2: Fn(MidValue2) -> Option<Value2>, S2_2: Fn(MutMid2) -> Option<MutValue2>, Lock: Clone, V: Clone, V2: Clone,

pub async fn get(&self, root: Root) -> Option<Value2>

Get through async lock then sync lock (root is passed here).

pub async fn get_mut(&self, root: MutRoot) -> Option<MutValue2>

Get mutable through async lock then sync lock (root is passed here).

impl<R, V2, Root, Value2, MutRoot, MutValue2, Lock3, Mid3, LockValue3, MidValue3, MutLock3, MutMid3, G3_1, S3_1, L3, G3_2, S3_2, First, Second> AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, ComposedAsyncLockKp<R, V2, Root, Value2, MutRoot, MutValue2, First, Second>, LockKp<Value2, Lock3, Mid3, V2, Value2, LockValue3, MidValue3, Value2, MutValue2, MutLock3, MutMid3, MutValue2, G3_1, S3_1, L3, G3_2, S3_2>>

where First: AsyncKeyPathLike<Root, MutRoot>, Second: AsyncKeyPathLike<First::Value, First::MutValue, Value = Value2, MutValue = MutValue2>, Value2: Borrow<V2> + Clone, MutValue2: BorrowMut<Value2> + BorrowMut<V2>, LockValue3: Borrow<Lock3>, MidValue3: Borrow<Mid3>, MutLock3: BorrowMut<Lock3>, MutMid3: BorrowMut<Mid3>, G3_1: Fn(Value2) -> Option<LockValue3>, S3_1: Fn(MutValue2) -> Option<MutLock3>, L3: LockAccess<Lock3, MidValue3> + LockAccess<Lock3, MutMid3>, G3_2: Fn(MidValue3) -> Option<Value2>, S3_2: Fn(MutMid3) -> Option<MutValue2>, V2: Clone,

pub async fn get(&self, root: Root) -> Option<Value2>

Get through composed async then sync lock (root is passed here).

pub async fn get_mut(&self, root: MutRoot) -> Option<MutValue2>

Get mutable through composed async then sync lock (root is passed here).

impl<R, V2, Root, Value2, MutRoot, MutValue2, Lock3, Mid3, LockValue3, MidValue3, MutLock3, MutMid3, G3_1, S3_1, L3, G3_2, S3_2, F, S> AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, F, S>, LockKp<Value2, Lock3, Mid3, V2, Value2, LockValue3, MidValue3, Value2, MutValue2, MutLock3, MutMid3, MutValue2, G3_1, S3_1, L3, G3_2, S3_2>>

where F: AsyncKeyPathLike<Root, MutRoot, Value = Value2, MutValue = MutValue2>, S: SyncKeyPathLike<Value2, Value2, MutValue2, MutValue2>, Value2: Borrow<V2> + Clone, MutValue2: BorrowMut<Value2> + BorrowMut<V2>, LockValue3: Borrow<Lock3>, MidValue3: Borrow<Mid3>, MutLock3: BorrowMut<Lock3>, MutMid3: BorrowMut<Mid3>, G3_1: Fn(Value2) -> Option<LockValue3>, S3_1: Fn(MutValue2) -> Option<MutLock3>, L3: LockAccess<Lock3, MidValue3> + LockAccess<Lock3, MutMid3>, G3_2: Fn(MidValue3) -> Option<Value2>, S3_2: Fn(MutMid3) -> Option<MutValue2>, V2: Clone,

pub async fn get(&self, root: Root) -> Option<Value2>

Get through async then sync then sync lock (root is passed here).

pub async fn get_mut(&self, root: MutRoot) -> Option<MutValue2>

Get mutable through async then sync then sync lock (root is passed here).

impl<R, V2, Root, Value2, MutRoot, MutValue2, First, Second> AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, First, Second>

where First: AsyncKeyPathLike<Root, MutRoot>,

pub fn then_async<Lock3, Mid3, V3, LockValue3, MidValue3, Value3, MutLock3, MutMid3, MutValue3, G3_1, S3_1, L3, G3_2, S3_2>( self, other: AsyncLockKp<Value2, Lock3, Mid3, V3, Value2, LockValue3, MidValue3, Value3, MutValue2, MutLock3, MutMid3, MutValue3, G3_1, S3_1, L3, G3_2, S3_2>, ) -> ComposedAsyncLockKp<Root, V3, Root, Value3, MutRoot, MutValue3, Self, AsyncLockKp<Value2, Lock3, Mid3, V3, Value2, LockValue3, MidValue3, Value3, MutValue2, MutLock3, MutMid3, MutValue3, G3_1, S3_1, L3, G3_2, S3_2>>

where V2: 'static, V3: 'static, Value2: Borrow<V2>, Value3: Borrow<V3>, MutValue2: BorrowMut<V2> + BorrowMut<Value2>, MutValue3: BorrowMut<V3>, LockValue3: Borrow<Lock3>, MidValue3: Borrow<Mid3>, MutLock3: BorrowMut<Lock3>, MutMid3: BorrowMut<Mid3>, G3_1: Fn(Value2) -> Option<LockValue3> + Clone, S3_1: Fn(MutValue2) -> Option<MutLock3> + Clone, L3: AsyncLockLike<Lock3, MidValue3> + AsyncLockLike<Lock3, MutMid3> + Clone, G3_2: Fn(MidValue3) -> Option<Value3> + Clone, S3_2: Fn(MutMid3) -> Option<MutValue3> + Clone, Lock3: Clone,

Chain with an async keypath (e.g. tokio RwLock): … -> Value2 -> async lock -> Value3. Use .get(&root).await or .get_mut(...).await on the returned ComposedAsyncLockKp.

pub fn then_lock<Lock3, Mid3, V3, LockValue3, MidValue3, Value3, MutLock3, MutMid3, MutValue3, G3_1, S3_1, L3, G3_2, S3_2>( self, lock_kp: LockKp<Value2, Lock3, Mid3, V3, Value2, LockValue3, MidValue3, Value3, MutValue2, MutLock3, MutMid3, MutValue3, G3_1, S3_1, L3, G3_2, S3_2>, ) -> AsyncLockKpThenLockKp<R, V3, Root, Value3, MutRoot, MutValue3, Self, LockKp<Value2, Lock3, Mid3, V3, Value2, LockValue3, MidValue3, Value3, MutValue2, MutLock3, MutMid3, MutValue3, G3_1, S3_1, L3, G3_2, S3_2>>

where V3: 'static, Value2: Borrow<V2>, Value3: Borrow<V3>, MutValue2: BorrowMut<Value2>, MutValue3: BorrowMut<V3>, LockValue3: Borrow<Lock3>, MidValue3: Borrow<Mid3>, MutLock3: BorrowMut<Lock3>, MutMid3: BorrowMut<Mid3>, G3_1: Fn(Value2) -> Option<LockValue3>, S3_1: Fn(MutValue2) -> Option<MutLock3>, L3: LockAccess<Lock3, MidValue3> + LockAccess<Lock3, MutMid3>, G3_2: Fn(MidValue3) -> Option<Value3>, S3_2: Fn(MutMid3) -> Option<MutValue3>,

Chain with another sync crate::lock::LockKp. Use .get(&root).await later.

pub fn then<V3, Value3, MutValue3, G3, S3>( self, next_kp: Kp<Value2, V3, Value2, Value3, MutValue2, MutValue3, G3, S3>, ) -> AsyncKeyPathThenKp<R, V3, Root, Value3, MutRoot, MutValue3, Self, Kp<Value2, V3, Value2, Value3, MutValue2, MutValue3, G3, S3>>

where V3: 'static, Value2: Borrow<V2>, Value3: Borrow<V3>, MutValue2: BorrowMut<Value2>, MutValue3: BorrowMut<V3>, G3: Fn(Value2) -> Option<Value3> + Clone, S3: Fn(MutValue2) -> Option<MutValue3> + Clone,

Chain with a regular crate::Kp. Use .get(&root).await later.

Trait Implementations

impl<R, V2, Root, Value2, MutRoot, MutValue2, First, Second> AsyncKeyPathLike<Root, MutRoot> for AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, First, Second>

where First: AsyncKeyPathLike<Root, MutRoot>, Second: SyncKeyPathLike<First::Value, Value2, First::MutValue, MutValue2>,

type Value = Value2

Value type at the end of the keypath.

type MutValue = MutValue2

Mutable value type at the end of the keypath.

fn get<'life0, 'async_trait>( &'life0 self, root: Root, ) -> Pin<Box<dyn Future<Output = Option<Value2>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the value at the end of the keypath.

fn get_mut<'life0, 'async_trait>( &'life0 self, root: MutRoot, ) -> Pin<Box<dyn Future<Output = Option<MutValue2>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get mutable access to the value at the end of the keypath.

impl<R: Clone, V2: Clone, Root: Clone, Value2: Clone, MutRoot: Clone, MutValue2: Clone, First: Clone, Second: Clone> Clone for AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, First, Second>

fn clone( &self, ) -> AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, First, Second>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.