Struct WritableOptionalKeyPath 

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

Implementations

impl<Root, Value, F> WritableOptionalKeyPath<Root, Value, F>

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

pub fn new(getter: F) -> WritableOptionalKeyPath<Root, Value, F>

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

pub fn trace_chain(&self, root: &mut Root) -> Result<(), String>

Trace the chain to find where it breaks Returns Ok(()) if the chain succeeds, or Err with diagnostic information

Example

let path = SomeComplexStruct::scsf_fw()
    .then(SomeOtherStruct::sosf_fw())
    .then(SomeEnum::b_case_fw());
 
match path.trace_chain(&mut instance) {
    Ok(()) => println!("Chain succeeded"),
    Err(msg) => println!("Chain broken: {}", msg),
}

pub fn for_option( self, ) -> WritableOptionalKeyPath<Option<Root>, Value, impl for<'r> Fn(&'r mut Option<Root>) + '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 Some value

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

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

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

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

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

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

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

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

pub fn for_result<E>( self, ) -> WritableOptionalKeyPath<Result<Root, E>, Value, impl for<'r> Fn(&'r mut Result<Root, E>) + '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 for_box_root( self, ) -> WritableOptionalKeyPath<Box<Root>, Value, impl for<'r> Fn(&'r mut Box<Root>) + 'static>

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

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

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

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

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

pub fn to_arc_rwlock_kp<InnerValue>( self, ) -> WritableOptionalKeyPath<Root, Value, F>

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

Convert this writable 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, ) -> WritableOptionalKeyPath<Root, Value, F>

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

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

pub fn to_arc_parking_rwlock_kp<InnerValue>( self, ) -> WritableOptionalKeyPath<Root, Value, F>

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

Convert this writable optional keypath to an Arc<parking_lot::RwLock> chain-ready keypath Returns self, but serves as a marker for intent and enables chaining

pub fn to_arc_parking_mutex_kp<InnerValue>( self, ) -> WritableOptionalKeyPath<Root, Value, F>

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

Convert this writable optional keypath to an Arc<parking_lot::Mutex> chain-ready keypath Returns self, but serves as a marker for intent and enables chaining

impl WritableOptionalKeyPath<(), (), fn(&mut ()) -> Option<&mut ()>>

pub fn for_option_static<T>() -> WritableOptionalKeyPath<Option<T>, T, impl for<'r> Fn(&'r mut Option<T>)>

pub fn writable_enum<Enum, Variant, EmbedFn, ReadExtractFn, WriteExtractFn>( _embedder: EmbedFn, _read_extractor: ReadExtractFn, write_extractor: WriteExtractFn, ) -> WritableOptionalKeyPath<Enum, Variant, impl for<'r> Fn(&'r mut Enum) + 'static>

where EmbedFn: Fn(Variant) -> Enum + 'static, ReadExtractFn: for<'r> Fn(&'r Enum) -> Option<&'r Variant> + 'static, WriteExtractFn: for<'r> Fn(&'r mut Enum) -> Option<&'r mut Variant> + 'static,

Backword compatibility method for writable enum keypath This allows both reading and writing to enum variant fields

Arguments

• embedder - Function to embed a value into the enum variant (for API consistency, not used)
• read_extractor - Function to extract a read reference from the enum (for API consistency, not used)
• write_extractor - Function to extract a mutable reference from the enum

Example

enum Color { Other(RGBU8) }
struct RGBU8(u8, u8, u8);
 
let case_path = WritableOptionalKeyPath::writable_enum(
    |v| Color::Other(v),
    |p: &Color| match p { Color::Other(rgb) => Some(rgb), _ => None },
    |p: &mut Color| match p { Color::Other(rgb) => Some(rgb), _ => None },
);

impl<Root, Value, F> WritableOptionalKeyPath<Root, Value, F>

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

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

Convert to PartialWritableOptionalKeyPath (hides Value type)

pub fn to_any(self) -> AnyWritableKeyPath

Convert to AnyWritableKeyPath (hides both Root and Value types)

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

Convert to PartialWritableOptionalKeyPath (alias for to_partial())

Trait Implementations

impl<Root, Value, F> Clone for WritableOptionalKeyPath<Root, Value, F>

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

fn clone(&self) -> WritableOptionalKeyPath<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 WritableOptionalKeyPath<Root, Value, F>

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

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

Formats the value using the given formatter.

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

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

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

Formats the value using the given formatter.

impl<Root, Value, F> From<WritableOptionalKeyPath<Root, Value, F>> for KP<Root>

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

fn from(kp: RustWritableOptionalKeyPath<Root, Value, F>) -> Self

Converts to this type from the input type.

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

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

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_tagged<Callback, R, Tag>( &self, _tagged: &Tagged<Root, Tag>, _f: Callback, ) -> R

where Tagged<Root, Tag>: Deref<Target = Root>, Callback: FnOnce(&Value) -> R,

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

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>