Struct OptionalKeyPath 

pub struct OptionalKeyPath<Root, Value, F>
where
    F: for<'r> Fn(&'r Root) -> Option<&'r Value>,
{ /* private fields */ }

Implementations

impl<Root, Value, F> OptionalKeyPath<Root, Value, F>

where F: for<'r> Fn(&'r Root) -> Option<&'r Value>,

pub fn new(getter: F) -> Self

pub fn get<'r>(&self, root: &'r Root) -> Option<&'r Value>

pub fn chain_arc_mutex_at_kp<InnerValue, SubValue, G>( self, inner_keypath: KeyPath<InnerValue, SubValue, G>, ) -> OptionalArcMutexKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r InnerValue) -> &'r SubValue,

Chain this optional keypath with an inner keypath through Arc<Mutex> - functional style Compose first, then apply container at get() time

Example

let container = ContainerTest { mutex_data: Some(Arc::new(Mutex::new(SomeStruct { data: "test".to_string() }))) };
 
// Functional style: compose first, apply container at get()
ContainerTest::mutex_data_fr()
    .chain_arc_mutex_at_kp(SomeStruct::data_r())
    .get(&container, |value| println!("Data: {}", value));

pub fn chain_arc_mutex_optional_at_kp<InnerValue, SubValue, G>( self, inner_keypath: OptionalKeyPath<InnerValue, SubValue, G>, ) -> OptionalArcMutexOptionalKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r InnerValue) -> Option<&'r SubValue>,

Chain this optional keypath with an optional inner keypath through Arc<Mutex> - functional style Compose first, then apply container at get() time

Example

let container = ContainerTest { mutex_data: Some(Arc::new(Mutex::new(SomeStruct { optional_field: Some("test".to_string()) }))) };
 
// Functional style: compose first, apply container at get()
ContainerTest::mutex_data_fr()
    .chain_arc_mutex_optional_at_kp(SomeStruct::optional_field_fr())
    .get(&container, |value| println!("Value: {}", value));

pub fn chain_arc_rwlock_at_kp<InnerValue, SubValue, G>( self, inner_keypath: KeyPath<InnerValue, SubValue, G>, ) -> OptionalArcRwLockKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r InnerValue) -> &'r SubValue,

Chain this optional keypath with an inner keypath through Arc<RwLock> - functional style Compose first, then apply container at get() time (uses read lock)

Example

let container = ContainerTest { rwlock_data: Some(Arc::new(RwLock::new(SomeStruct { data: "test".to_string() }))) };
 
// Functional style: compose first, apply container at get()
ContainerTest::rwlock_data_fr()
    .chain_arc_rwlock_at_kp(SomeStruct::data_r())
    .get(&container, |value| println!("Data: {}", value));

pub fn chain_arc_rwlock_optional_at_kp<InnerValue, SubValue, G>( self, inner_keypath: OptionalKeyPath<InnerValue, SubValue, G>, ) -> OptionalArcRwLockOptionalKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r InnerValue) -> Option<&'r SubValue>,

Chain this optional keypath with an optional inner keypath through Arc<RwLock> - functional style Compose first, then apply container at get() time (uses read lock)

Example

let container = ContainerTest { rwlock_data: Some(Arc::new(RwLock::new(SomeStruct { optional_field: Some("test".to_string()) }))) };
 
// Functional style: compose first, apply container at get()
ContainerTest::rwlock_data_fr()
    .chain_arc_rwlock_optional_at_kp(SomeStruct::optional_field_fr())
    .get(&container, |value| println!("Value: {}", value));

pub fn chain_arc_mutex_writable_at_kp<InnerValue, SubValue, G>( self, inner_keypath: WritableKeyPath<InnerValue, SubValue, G>, ) -> OptionalArcMutexWritableKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r mut InnerValue) -> &'r mut SubValue,

Chain this optional keypath with a writable inner keypath through Arc<Mutex> - functional style Compose first, then apply container at get_mut() time

Example

let container = ContainerTest { mutex_data: Some(Arc::new(Mutex::new(SomeStruct { data: "test".to_string() }))) };
 
// Functional style: compose first, apply container at get_mut()
ContainerTest::mutex_data_fr()
    .chain_arc_mutex_writable_at_kp(SomeStruct::data_w())
    .get_mut(&container, |value| *value = "new".to_string());

pub fn chain_arc_mutex_writable_optional_at_kp<InnerValue, SubValue, G>( self, inner_keypath: WritableOptionalKeyPath<InnerValue, SubValue, G>, ) -> OptionalArcMutexWritableOptionalKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r mut InnerValue) -> Option<&'r mut SubValue>,

Chain this optional keypath with a writable optional inner keypath through Arc<Mutex> - functional style Compose first, then apply container at get_mut() time

Example

let container = ContainerTest { mutex_data: Some(Arc::new(Mutex::new(SomeStruct { optional_field: Some("test".to_string()) }))) };
 
// Functional style: compose first, apply container at get_mut()
ContainerTest::mutex_data_fr()
    .chain_arc_mutex_writable_optional_at_kp(SomeStruct::optional_field_fw())
    .get_mut(&container, |value| *value = "new".to_string());

pub fn chain_arc_rwlock_writable_at_kp<InnerValue, SubValue, G>( self, inner_keypath: WritableKeyPath<InnerValue, SubValue, G>, ) -> OptionalArcRwLockWritableKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r mut InnerValue) -> &'r mut SubValue,

Chain this optional keypath with a writable inner keypath through Arc<RwLock> - functional style Compose first, then apply container at get_mut() time (uses write lock)

Example

let container = ContainerTest { rwlock_data: Some(Arc::new(RwLock::new(SomeStruct { data: "test".to_string() }))) };
 
// Functional style: compose first, apply container at get_mut()
ContainerTest::rwlock_data_fr()
    .chain_arc_rwlock_writable_at_kp(SomeStruct::data_w())
    .get_mut(&container, |value| *value = "new".to_string());

pub fn chain_arc_rwlock_writable_optional_at_kp<InnerValue, SubValue, G>( self, inner_keypath: WritableOptionalKeyPath<InnerValue, SubValue, G>, ) -> OptionalArcRwLockWritableOptionalKeyPathChain<Root, Value, InnerValue, SubValue, F, G>

where G: for<'r> Fn(&'r mut InnerValue) -> Option<&'r mut SubValue>,

Chain this optional keypath with a writable optional inner keypath through Arc<RwLock> - functional style Compose first, then apply container at get_mut() time (uses write lock)

Example

let container = ContainerTest { rwlock_data: Some(Arc::new(RwLock::new(SomeStruct { optional_field: Some("test".to_string()) }))) };
 
// Functional style: compose first, apply container at get_mut()
ContainerTest::rwlock_data_fr()
    .chain_arc_rwlock_writable_optional_at_kp(SomeStruct::optional_field_fw())
    .get_mut(&container, |value| *value = "new".to_string());

pub fn then<SubValue, G>( self, next: OptionalKeyPath<Value, SubValue, G>, ) -> OptionalKeyPath<Root, SubValue, impl for<'r> Fn(&'r Root) -> Option<&'r SubValue>>

where G: for<'r> Fn(&'r Value) -> Option<&'r SubValue> + 'static, F: 'static, Value: 'static,

pub fn for_box<Target>( self, ) -> OptionalKeyPath<Root, Target, impl for<'r> Fn(&'r Root) -> Option<&'r Target> + 'static>

where Value: Deref<Target = Target> + 'static, F: 'static,

pub fn for_arc<Target>( self, ) -> OptionalKeyPath<Root, Target, impl for<'r> Fn(&'r Root) -> Option<&'r Target> + 'static>

where Value: Deref<Target = Target> + 'static, F: 'static,

pub fn for_rc<Target>( self, ) -> OptionalKeyPath<Root, Target, impl for<'r> Fn(&'r Root) -> Option<&'r Target> + 'static>

where Value: Deref<Target = Target> + 'static, F: 'static,

pub fn for_option( self, ) -> OptionalKeyPath<Option<Root>, Value, impl for<'r> Fn(&'r Option<Root>) -> Option<&'r Value> + 'static>

where F: 'static, Root: 'static, Value: 'static,

Adapt this keypath to work with Option instead of Root This unwraps the Option and applies the keypath to the inner value

pub fn for_result<E>( self, ) -> OptionalKeyPath<Result<Root, E>, Value, impl for<'r> Fn(&'r Result<Root, E>) -> Option<&'r Value> + 'static>

where F: 'static, Root: 'static, Value: 'static, E: 'static,

Adapt this keypath to work with Result<Root, E> instead of Root This unwraps the Result and applies the keypath to the Ok value

pub fn to_arc_rwlock_kp<InnerValue>(self) -> Self

where Value: Borrow<Arc<RwLock<InnerValue>>>,

Convert this optional keypath to an Arc chain-ready keypath Returns self, but serves as a marker for intent and enables chaining

pub fn to_arc_mutex_kp<InnerValue>(self) -> Self

where Value: Borrow<Arc<Mutex<InnerValue>>>,

Convert this optional keypath to an Arc chain-ready keypath Returns self, but serves as a marker for intent and enables chaining

pub fn to_arc_rwlock_chain<InnerValue>( self, ) -> OptionalArcRwLockKeyPathChain<Root, Value, InnerValue, InnerValue, F, impl for<'r> Fn(&'r InnerValue) -> &'r InnerValue + 'static>

where Value: Borrow<Arc<RwLock<InnerValue>>>, F: 'static, InnerValue: 'static,

Convert this optional keypath to an Arc chain keypath Creates a chain with an identity inner keypath, ready for further chaining Type inference automatically determines InnerValue from Value

pub fn to_arc_mutex_chain<InnerValue>( self, ) -> OptionalArcMutexKeyPathChain<Root, Value, InnerValue, InnerValue, F, impl for<'r> Fn(&'r InnerValue) -> &'r InnerValue + 'static>

where Value: Borrow<Arc<Mutex<InnerValue>>>, F: 'static, InnerValue: 'static,

Convert this optional keypath to an Arc chain keypath Creates a chain with an identity inner keypath, ready for further chaining Type inference automatically determines InnerValue from Value

pub fn for_arc_root( self, ) -> OptionalKeyPath<Arc<Root>, Value, impl for<'r> Fn(&'r Arc<Root>) -> Option<&'r Value> + 'static>

where Value: Sized + 'static, F: 'static, Root: 'static,

pub fn for_rc_root( self, ) -> OptionalKeyPath<Rc<Root>, Value, impl for<'r> Fn(&'r Rc<Root>) -> Option<&'r Value> + 'static>

where Value: Sized + 'static, F: 'static, Root: 'static,

pub fn with_option<Callback, R>( &self, option: &Option<Root>, f: Callback, ) -> Option<R>

where F: Clone, Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Option

pub fn with_mutex<Callback, R>( &self, mutex: &Mutex<Root>, f: Callback, ) -> Option<R>

where F: Clone, Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside a Mutex

pub fn with_rwlock<Callback, R>( &self, rwlock: &RwLock<Root>, f: Callback, ) -> Option<R>

where F: Clone, Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an RwLock

pub fn with_arc_rwlock<Callback, R>( &self, arc_rwlock: &Arc<RwLock<Root>>, f: Callback, ) -> Option<R>

where F: Clone, Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Arc<RwLock>

pub fn with_arc_rwlock_direct<Callback, R>( &self, arc_rwlock: &Arc<RwLock<Root>>, f: Callback, ) -> Option<R>

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Arc<RwLock> This is a convenience method that works directly with Arc<RwLock> Unlike with_arc_rwlock, this doesn’t require F: Clone

pub fn with_arc_mutex<Callback, R>( &self, arc_mutex: &Arc<Mutex<Root>>, f: Callback, ) -> Option<R>

where F: Clone, Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Arc<Mutex>

impl<Root, Value, F> OptionalKeyPath<Root, Value, F>

where F: for<'r> Fn(&'r Root) -> Option<&'r Value> + 'static, Root: Any + 'static, Value: Any + 'static,

pub fn to_partial(self) -> PartialOptionalKeyPath<Root>

Convert to PartialOptionalKeyPath (hides Value type)

pub fn to_any(self) -> AnyKeyPath

Convert to AnyKeyPath (hides both Root and Value types)

pub fn to(self) -> PartialOptionalKeyPath<Root>

Convert to PartialOptionalKeyPath (alias for to_partial())

Trait Implementations

impl<Root: Clone, Value: Clone, F> Clone for OptionalKeyPath<Root, Value, F>

where F: for<'r> Fn(&'r Root) -> Option<&'r Value> + Clone,

fn clone(&self) -> OptionalKeyPath<Root, Value, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Root, Value, F> Debug for OptionalKeyPath<Root, Value, F>

where F: for<'r> Fn(&'r Root) -> Option<&'r Value>,

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

Formats the value using the given formatter.

impl<Root, Value, F> Display for OptionalKeyPath<Root, Value, F>

where F: for<'r> Fn(&'r Root) -> Option<&'r Value>,

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

Formats the value using the given formatter.

impl<Root, Value, F> WithContainer<Root, Value> for OptionalKeyPath<Root, Value, F>

where F: for<'r> Fn(&'r Root) -> Option<&'r Value> + Clone,

fn with_arc<Callback, R>(&self, arc: &Arc<Root>, f: Callback) -> R

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Arc

fn with_box<Callback, R>(&self, boxed: &Box<Root>, f: Callback) -> R

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside a Box

fn with_box_mut<Callback, R>(&self, _boxed: &mut Box<Root>, _f: Callback) -> R

where Callback: FnOnce(&mut Value) -> R,

Execute a closure with a mutable reference to the value inside a Box

fn with_rc<Callback, R>(&self, rc: &Rc<Root>, f: Callback) -> R

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Rc

fn with_result<Callback, R, E>( &self, result: &Result<Root, E>, f: Callback, ) -> Option<R>

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside a Result

fn with_result_mut<Callback, R, E>( &self, _result: &mut Result<Root, E>, _f: Callback, ) -> Option<R>

where Callback: FnOnce(&mut Value) -> R,

Execute a closure with a mutable reference to the value inside a Result

fn with_option<Callback, R>( &self, option: &Option<Root>, f: Callback, ) -> Option<R>

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Option

fn with_option_mut<Callback, R>( &self, _option: &mut Option<Root>, _f: Callback, ) -> Option<R>

where Callback: FnOnce(&mut Value) -> R,

Execute a closure with a mutable reference to the value inside an Option

fn with_refcell<Callback, R>( &self, refcell: &RefCell<Root>, f: Callback, ) -> Option<R>

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside a RefCell

fn with_refcell_mut<Callback, R>( &self, _refcell: &RefCell<Root>, _f: Callback, ) -> Option<R>

where Callback: FnOnce(&mut Value) -> R,

Execute a closure with a mutable reference to the value inside a RefCell

fn with_mutex<Callback, R>(&self, mutex: &Mutex<Root>, f: Callback) -> Option<R>

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside a Mutex

fn with_mutex_mut<Callback, R>( &self, _mutex: &mut Mutex<Root>, _f: Callback, ) -> Option<R>

where Callback: FnOnce(&mut Value) -> R,

Execute a closure with a mutable reference to the value inside a Mutex

fn with_rwlock<Callback, R>( &self, rwlock: &RwLock<Root>, f: Callback, ) -> Option<R>

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an RwLock

fn with_rwlock_mut<Callback, R>( &self, _rwlock: &mut RwLock<Root>, _f: Callback, ) -> Option<R>

where Callback: FnOnce(&mut Value) -> R,

Execute a closure with a mutable reference to the value inside an RwLock

fn with_arc_rwlock<Callback, R>( &self, arc_rwlock: &Arc<RwLock<Root>>, f: Callback, ) -> Option<R>

where Callback: FnOnce(&Value) -> R,

Execute a closure with a reference to the value inside an Arc<RwLock>

fn with_arc_rwlock_mut<Callback, R>( &self, _arc_rwlock: &Arc<RwLock<Root>>, _f: Callback, ) -> Option<R>

where Callback: FnOnce(&mut Value) -> R,

Execute a closure with a mutable reference to the value inside an Arc<RwLock>