Struct bevy_reflect::ParsedPath

pub struct ParsedPath(_);

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

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.

Implementations

impl ParsedPath

pub fn parse(string: &str) -> Result<Self, 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 reflect_element<'r, 'p>( &'p self, root: &'r dyn Reflect ) -> Result<&'r dyn Reflect, ReflectPathError<'p>>

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

Returns an error if the path is invalid for the provided type.

See element_mut for a typed version of this method.

pub fn reflect_element_mut<'r, 'p>( &'p mut self, root: &'r mut dyn Reflect ) -> Result<&'r mut dyn Reflect, ReflectPathError<'p>>

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

Returns an error if the path is invalid for the provided type.

See element_mut for a typed version of this method.

pub fn element<'r, 'p, T: Reflect>( &'p self, root: &'r dyn Reflect ) -> Result<&'r T, ReflectPathError<'p>>

Gets a typed, read-only reference to the specified element on the given Reflect object.

Returns an error if the path is invalid for the provided type.

See reflect_element for an untyped version of this method.

pub fn element_mut<'r, 'p, T: Reflect>( &'p mut self, root: &'r mut dyn Reflect ) -> Result<&'r mut T, ReflectPathError<'p>>

Gets a typed, read-only reference to the specified element on the given Reflect object.

Returns an error if the path is invalid for the provided type.

See reflect_element_mut for an untyped version of this method.

Trait Implementations

impl Clone for ParsedPath

fn clone(&self) -> ParsedPath

Returns a copy 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

Formats the value using the given formatter.

impl Display for ParsedPath

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

Formats the value using the given formatter.

impl Hash for ParsedPath

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

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 Ord for ParsedPath

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<ParsedPath> for ParsedPath

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<ParsedPath> 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for ParsedPath

impl StructuralEq for ParsedPath

impl StructuralPartialEq for ParsedPath