Struct ParsedPath 

pub struct ParsedPath(pub Vec<OffsetAccess>);

A pre-parsed path to an element within a type.

This struct can be constructed manually from its Accesses or with the parse method.

This struct may be used like GetPath but removes the cost of parsing the path string at each element access.

It’s recommended to use this in place of GetPath when the path string is unlikely to be changed and will be accessed repeatedly.

Examples

Parsing a &'static str:

let my_static_string: &'static str = "bar#0.1[2].0";
// Breakdown:
//   "bar" - Access struct field named "bar"
//   "#0" - Access struct field at index 0
//   ".1" - Access tuple struct field at index 1
//   "[2]" - Access list element at index 2
//   ".0" - Access tuple variant field at index 0
let my_path = ParsedPath::parse_static(my_static_string);

Parsing a non-static &str:

let my_string = String::from("bar#0.1[2].0");
// Breakdown:
//   "bar" - Access struct field named "bar"
//   "#0" - Access struct field at index 0
//   ".1" - Access tuple struct field at index 1
//   "[2]" - Access list element at index 2
//   ".0" - Access tuple variant field at index 0
let my_path = ParsedPath::parse(&my_string);

Manually constructing a ParsedPath:

let path_elements = [
    Access::Field(Cow::Borrowed("bar")),
    Access::FieldIndex(0),
    Access::TupleIndex(1),
    Access::ListIndex(2),
    Access::TupleIndex(1),
];
let my_path = ParsedPath::from(path_elements);

Tuple Fields

0: Vec<OffsetAccess>

This is a vector of pre-parsed OffsetAccesses.

Implementations

impl ParsedPath

pub fn parse(string: &str) -> Result<ParsedPath, ReflectPathError<'_>>

Parses a ParsedPath from a string.

Returns an error if the string does not represent a valid path to an element.

The exact format for path strings can be found in the documentation for GetPath. In short, though, a path consists of one or more chained accessor strings. These are:

• Named field access (.field)
• Unnamed field access (.1)
• Field index access (#0)
• Sequence access ([2])

Example

#[derive(Reflect)]
struct Foo {
  bar: Bar,
}

#[derive(Reflect)]
struct Bar {
  baz: Baz,
}

#[derive(Reflect)]
struct Baz(f32, Vec<Option<u32>>);

let foo = Foo {
  bar: Bar {
    baz: Baz(3.14, vec![None, None, Some(123)])
  },
};

let parsed_path = ParsedPath::parse("bar#0.1[2].0").unwrap();
// Breakdown:
//   "bar" - Access struct field named "bar"
//   "#0" - Access struct field at index 0
//   ".1" - Access tuple struct field at index 1
//   "[2]" - Access list element at index 2
//   ".0" - Access tuple variant field at index 0

assert_eq!(parsed_path.element::<u32>(&foo).unwrap(), &123);

pub fn parse_static( string: &'static str, ) -> Result<ParsedPath, ReflectPathError<'static>>

Similar to Self::parse but only works on &'static str and does not allocate per named field.

Trait Implementations

impl Clone for ParsedPath

fn clone(&self) -> ParsedPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParsedPath

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

Formats the value using the given formatter.

impl Display for ParsedPath

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

Formats the value using the given formatter.

impl<const N: usize> From<[Access<'static>; N]> for ParsedPath

fn from(value: [Access<'static>; N]) -> ParsedPath

Converts to this type from the input type.

impl<const N: usize> From<[OffsetAccess; N]> for ParsedPath

fn from(value: [OffsetAccess; N]) -> ParsedPath

Converts to this type from the input type.

impl From<Vec<Access<'static>>> for ParsedPath

fn from(value: Vec<Access<'static>>) -> ParsedPath

Converts to this type from the input type.

impl From<Vec<OffsetAccess>> for ParsedPath

fn from(value: Vec<OffsetAccess>) -> ParsedPath

Converts to this type from the input type.

impl Hash for ParsedPath

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for ParsedPath

type Output = OffsetAccess

The returned type after indexing.

fn index(&self, index: usize) -> &<ParsedPath as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for ParsedPath

fn index_mut( &mut self, index: usize, ) -> &mut <ParsedPath as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl Ord for ParsedPath

fn cmp(&self, other: &ParsedPath) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ParsedPath

fn eq(&self, other: &ParsedPath) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ParsedPath

fn partial_cmp(&self, other: &ParsedPath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> ReflectPath<'a> for &'a ParsedPath

fn reflect_element( self, root: &(dyn PartialReflect + 'static), ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'a>>

Gets a reference to the specified element on the given Reflect object.

fn reflect_element_mut( self, root: &mut (dyn PartialReflect + 'static), ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'a>>

Gets a mutable reference to the specified element on the given Reflect object.

fn element<T>( self, root: &(dyn PartialReflect + 'static), ) -> Result<&T, ReflectPathError<'a>>

where T: Reflect,

Gets a &T to the specified element on the given Reflect object.

fn element_mut<T>( self, root: &mut (dyn PartialReflect + 'static), ) -> Result<&mut T, ReflectPathError<'a>>

where T: Reflect,

Gets a &mut T to the specified element on the given Reflect object.

impl<'a> TryFrom<&'a str> for ParsedPath

type Error = ReflectPathError<'a>

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<ParsedPath, <ParsedPath as TryFrom<&'a str>>::Error>

Performs the conversion.

impl Eq for ParsedPath

impl StructuralPartialEq for ParsedPath