Struct PKp 

pub struct PKp<Root> { /* private fields */ }

Implementations

impl<Root> PKp<Root>

where Root: 'static,

pub fn new<'a, V>(keypath: KpType<'a, Root, V>) -> Self

where V: Any + 'static,

Create a new PKp from a KpType (the common reference-based keypath)

pub fn from<'a, V>(keypath: KpType<'a, Root, V>) -> Self

where V: Any + 'static,

Create a PKp from a KpType (alias for new())

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

Get the value as a trait object

pub fn value_type_id(&self) -> TypeId

Get the TypeId of the Value type

pub fn get_as<'a, Value: Any>(&self, root: &'a Root) -> Option<&'a Value>

Try to downcast the result to a specific type

pub fn kind_name(&self) -> String

Get a human-readable name for the value type

pub fn for_arc(&self) -> PKp<Arc<Root>>

Adapt this keypath to work with Arc instead of Root

pub fn for_box(&self) -> PKp<Box<Root>>

Adapt this keypath to work with Box instead of Root

pub fn for_rc(&self) -> PKp<Rc<Root>>

Adapt this keypath to work with Rc instead of Root

pub fn for_option(&self) -> PKp<Option<Root>>

Adapt this keypath to work with Option instead of Root

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

where E: 'static,

Adapt this keypath to work with Result<Root, E> instead of Root

pub fn map<OrigValue, MappedValue, F>(&self, mapper: F) -> PKp<Root>

where OrigValue: Any + 'static, MappedValue: Any + 'static, F: Fn(&OrigValue) -> MappedValue + 'static,

Map the value through a transformation function The mapped value must also implement Any for type erasure

Example

use rust_key_paths::{Kp, KpType, PKp};
struct User { name: String }
let user = User { name: "Alice".to_string() };
let name_kp = KpType::new(|u: &User| Some(&u.name), |_| None);
let name_pkp = PKp::new(name_kp);
let len_pkp = name_pkp.map::<String, _, _>(|s| s.len());
assert_eq!(len_pkp.get_as::<usize>(&user), Some(&5));

pub fn filter<Value, F>(&self, predicate: F) -> PKp<Root>

where Value: Any + 'static, F: Fn(&Value) -> bool + 'static,

Filter the value based on a predicate with type checking Returns None if the type doesn’t match or predicate fails

Example

use rust_key_paths::{Kp, KpType, PKp};
struct User { age: i32 }
let user = User { age: 30 };
let age_kp = KpType::new(|u: &User| Some(&u.age), |_| None);
let age_pkp = PKp::new(age_kp);
let adult_pkp = age_pkp.filter::<i32, _>(|age| *age >= 18);
assert_eq!(adult_pkp.get_as::<i32>(&user), Some(&30));