Struct WritableKeyPath 

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

Implementations

impl<Root, Value, F> WritableKeyPath<Root, Value, F>

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

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

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

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, ) -> WritableKeyPath<Box<Root>, Value, impl for<'r> Fn(&'r mut Box<Root>) + 'static>

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

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 to_optional( self, ) -> WritableOptionalKeyPath<Root, Value, impl for<'r> Fn(&'r mut Root) + 'static>

where F: 'static,

Convert a WritableKeyPath to WritableOptionalKeyPath for chaining This allows non-optional writable keypaths to be chained with then()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn iter_mut<'r, T>(&self, root: &'r mut Root) -> Option<IterMut<'r, T>>

where Value: AsMut<[T]> + 'r,

Get a mutable iterator over a Vec when Value is Vec Returns Some(iterator) if the value is a Vec, None otherwise

pub fn extract_mut_from_slice<'r>( &self, slice: &'r mut [Root], ) -> Vec<&'r mut Value>

Extract mutable values from a slice of owned mutable values Returns a Vec of mutable references to the extracted values

pub fn extract_mut_from_ref_slice<'r>( &self, slice: &'r mut [&'r mut Root], ) -> Vec<&'r mut Value>

Extract mutable values from a slice of mutable references Returns a Vec of mutable references to the extracted values

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

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

Chain this keypath with another writable keypath Returns a WritableKeyPath that chains both keypaths

pub fn then_optional<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,

Chain this keypath with a writable optional keypath Returns a WritableOptionalKeyPath that chains both keypaths

impl<Root, Value, F> WritableKeyPath<Root, Value, F>

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

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

Convert to PartialWritableKeyPath (hides Value type)

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

Alias for to_partial() - converts to PartialWritableKeyPath

Trait Implementations

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

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

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

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

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

Formats the value using the given formatter.

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

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

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

Formats the value using the given formatter.

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

where F: for<'r> Fn(&'r mut Root) -> &'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_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>