Enum PartialKeyPath 

pub enum PartialKeyPath<Root> {
    Readable(Arc<dyn for<'a> Fn(&'a Root) -> &'a (dyn Any + Send + Sync) + Send + Sync>),
    ReadableEnum {
        extract: Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>,
        embed: Arc<dyn Fn(Box<dyn Any>) -> Root + Send + Sync>,
    },
    FailableReadable(Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>),
    Writable(Arc<dyn for<'a> Fn(&'a mut Root) -> &'a mut (dyn Any + Send + Sync) + Send + Sync>),
    FailableWritable(Arc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut (dyn Any + Send + Sync)> + Send + Sync>),
    WritableEnum {
        extract: Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>,
        extract_mut: Arc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut (dyn Any + Send + Sync)> + Send + Sync>,
        embed: Arc<dyn Fn(Box<dyn Any>) -> Root + Send + Sync>,
    },
    ReferenceWritable(Arc<dyn for<'a> Fn(&'a mut Root) -> &'a mut (dyn Any + Send + Sync) + Send + Sync>),
    Owned(Arc<dyn Fn(Root) -> Box<dyn Any> + Send + Sync>),
    FailableOwned(Arc<dyn Fn(Root) -> Option<Box<dyn Any>> + Send + Sync>),
    FailableCombined {
        readable: Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>,
        writable: Arc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut (dyn Any + Send + Sync)> + Send + Sync>,
        owned: Arc<dyn Fn(Root) -> Option<Box<dyn Any>> + Send + Sync>,
    },
}

PartialKeyPath - Type-erased keypath with known Root but unknown Value Equivalent to Swift’s PartialKeyPath Useful for collections of keypaths from the same root type but with different value types

Variants

Readable(Arc<dyn for<'a> Fn(&'a Root) -> &'a (dyn Any + Send + Sync) + Send + Sync>)

ReadableEnum

Fields

extract: Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>

embed: Arc<dyn Fn(Box<dyn Any>) -> Root + Send + Sync>

FailableReadable(Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>)

Writable(Arc<dyn for<'a> Fn(&'a mut Root) -> &'a mut (dyn Any + Send + Sync) + Send + Sync>)

FailableWritable(Arc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut (dyn Any + Send + Sync)> + Send + Sync>)

WritableEnum

Fields

extract: Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>

extract_mut: Arc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut (dyn Any + Send + Sync)> + Send + Sync>

embed: Arc<dyn Fn(Box<dyn Any>) -> Root + Send + Sync>

ReferenceWritable(Arc<dyn for<'a> Fn(&'a mut Root) -> &'a mut (dyn Any + Send + Sync) + Send + Sync>)

Owned(Arc<dyn Fn(Root) -> Box<dyn Any> + Send + Sync>)

FailableOwned(Arc<dyn Fn(Root) -> Option<Box<dyn Any>> + Send + Sync>)

FailableCombined

Fields

readable: Arc<dyn for<'a> Fn(&'a Root) -> Option<&'a (dyn Any + Send + Sync)> + Send + Sync>

writable: Arc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut (dyn Any + Send + Sync)> + Send + Sync>

owned: Arc<dyn Fn(Root) -> Option<Box<dyn Any>> + Send + Sync>

Implementations

impl<Root> PartialKeyPath<Root>

pub fn get<'a>(&'a self, root: &'a Root) -> Option<&'a (dyn Any + Send + Sync)>

Get an immutable reference if possible

pub fn get_mut<'a>( &'a self, root: &'a mut Root, ) -> Option<&'a mut (dyn Any + Send + Sync)>

Get a mutable reference if possible

pub fn get_owned(self, root: Root) -> Box<dyn Any>

Get an owned value (primary method for owned keypaths)

pub fn get_failable_owned(self, root: Root) -> Option<Box<dyn Any>>

Get an owned value with failable access

pub fn to_any(self) -> AnyKeyPath

where Root: 'static,

Convert this PartialKeyPath to an AnyKeyPath (fully type-erased)

pub fn kind_name(&self) -> &'static str

Get the kind name of this keypath

pub fn for_arc(self) -> PartialKeyPath<Arc<Root>>

where Root: 'static + Clone,

Adapt this PartialKeyPath to work with Arc

pub fn for_box(self) -> PartialKeyPath<Box<Root>>

where Root: 'static,

Adapt this PartialKeyPath to work with Box

pub fn for_rc(self) -> PartialKeyPath<Rc<Root>>

where Root: 'static + Clone,

Adapt this PartialKeyPath to work with Rc

pub fn for_result<E>(self) -> PartialKeyPath<Result<Root, E>>

where Root: 'static,

Adapt this PartialKeyPath to work with Result<Root, E>

pub fn for_option(self) -> PartialKeyPath<Option<Root>>

where Root: 'static,

Adapt this PartialKeyPath to work with Option

pub fn for_arc_rwlock(self) -> PartialKeyPath<Arc<RwLock<Root>>>

where Root: 'static + Clone,

Adapt this PartialKeyPath to work with Arc<RwLock> Note: This only supports owned keypaths due to guard lifetime constraints

pub fn for_arc_mutex(self) -> PartialKeyPath<Arc<Mutex<Root>>>

where Root: 'static + Clone,

Adapt this PartialKeyPath to work with Arc<Mutex> Note: This only supports owned keypaths due to guard lifetime constraints

Trait Implementations

impl<Root: Clone> Clone for PartialKeyPath<Root>

fn clone(&self) -> PartialKeyPath<Root>

Returns a duplicate of the value.

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

Performs copy-assignment from source.