Struct AKp 

pub struct AKp { /* private fields */ }

Implementations

impl AKp

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

where R: Any + 'static, V: Any + 'static,

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

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

where R: Any + 'static, V: Any + 'static,

Create an AKp from a KpType (alias for new())

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

Get the value as a trait object (with root type checking)

pub fn root_type_id(&self) -> TypeId

Get the TypeId of the Root type

pub fn value_type_id(&self) -> TypeId

Get the TypeId of the Value type

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

Try to get the value with full type checking

pub fn kind_name(&self) -> String

Get a human-readable name for the value type

pub fn root_kind_name(&self) -> String

Get a human-readable name for the root type

pub fn for_arc<Root>(&self) -> AKp

where Root: Any + 'static,

Adapt this keypath to work with Arc instead of Root

pub fn for_box<Root>(&self) -> AKp

where Root: Any + 'static,

Adapt this keypath to work with Box instead of Root

pub fn for_rc<Root>(&self) -> AKp

where Root: Any + 'static,

Adapt this keypath to work with Rc instead of Root

pub fn for_option<Root>(&self) -> AKp

where Root: Any + 'static,

Adapt this keypath to work with Option instead of Root

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

where Root: Any + 'static, E: Any + 'static,

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

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

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

Map the value through a transformation function with type checking Both original and mapped values must implement Any

Example

use rust_key_paths::{AKp, Kp, KpType};
struct User { name: String }
let user = User { name: "Alice".to_string() };
let name_kp = KpType::new(|u: &User| Some(&u.name), |_| None);
let name_akp = AKp::new(name_kp);
let len_akp = name_akp.map::<User, String, _, _>(|s| s.len());

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

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

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

Example

use rust_key_paths::{AKp, Kp, KpType};
struct User { age: i32 }
let user = User { age: 30 };
let age_kp = KpType::new(|u: &User| Some(&u.age), |_| None);
let age_akp = AKp::new(age_kp);
let adult_akp = age_akp.filter::<User, i32, _>(|age| *age >= 18);