Struct XPath 

pub struct XPath { /* private fields */ }

Cross Path allowing to recursively retrieve a FieldValue from a structure implementing FieldGetter.

Example:

use ::gene_derive::FieldGetter;
use ::gene::{XPath, FieldGetter, FieldValue, FieldNameIterator};

#[derive(FieldGetter)]
struct LogData
{
    a: String,
    b: i32,
    c: f64,
}

#[derive(FieldGetter)]
struct LogEntry
{
    name: String,
    data: LogData,
}

let e = LogEntry{
    name: "SomeEntry".into(),
    data: LogData{
        a: "SomeData".into(),
        b: 42,
        c: 24.0,
    }
};

let p = XPath::parse(".name").unwrap();
assert_eq!(e.get_from_path(&p), Some("SomeEntry".into()));

let p = XPath::parse(".data.a").unwrap();
assert_eq!(e.get_from_path(&p), Some("SomeData".into()));

let p = XPath::parse(".data.b").unwrap();
assert_eq!(e.get_from_path(&p), Some(42.into()));

let p = XPath::parse(".data.c").unwrap();
assert_eq!(e.get_from_path(&p), Some(24.0.into()));

Implementations

impl XPath

pub fn parse<S: AsRef<str>>(s: S) -> Result<Self, PathError>

Parses a string into an XPath.

Creates an XPath from a string representation, validating the path structure and extracting segments. The path string should use dot notation (e.g., .field.subfield) to represent nested field access.

Errors

Returns PathError if the path string is malformed or contains invalid characters.

Examples

use gene::XPath;

let path = XPath::parse(".field.subfield").unwrap();
assert_eq!(path.to_string_lossy(), ".field.subfield");

pub fn segments(&self) -> &[String]

Returns a reference to the segments of this path.

Path segments are the individual components extracted from the path string. For a path like .a.b.c, the segments will be ["a", "b", "c"]. The dot (.) character is used as the segment separator.

Examples

use gene::XPath;

let path = XPath::parse(".field.subfield").unwrap();
let segments = path.segments();
assert_eq!(segments, &vec!["field".to_string(), "subfield".to_string()]);

pub fn iter_segments(&self) -> Iter<'_, String>

Returns an iterator over the segments of this path.

This provides a more efficient way to access path segments when you need to iterate over them rather than access the full vector. The iterator yields string references to each segment.

Examples

use gene::XPath;

let path = XPath::parse(".field.subfield").unwrap();
let mut iter = path.iter_segments();
assert_eq!(iter.next(), Some(&"field".to_string()));
assert_eq!(iter.next(), Some(&"subfield".to_string()));
assert_eq!(iter.next(), None);

pub fn to_string_lossy(&self) -> Cow<'_, str>

Returns a borrowed string representation of this path.

This method provides efficient access to the original path string without allocation. The returned Cow will typically be a borrowed reference to the internal string data.

Examples

use gene::XPath;

let path = XPath::parse(".field.subfield").unwrap();
assert_eq!(path.to_string_lossy(), ".field.subfield");

Trait Implementations

impl Clone for XPath

fn clone(&self) -> XPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for XPath

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

Formats the value using the given formatter.

impl Display for XPath

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

Formats the value using the given formatter.

impl<'f> From<&'f XPath> for FieldNameIterator<'f>

fn from(value: &'f XPath) -> Self

Converts to this type from the input type.

impl FromStr for XPath

type Err = PathError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for XPath

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 PartialEq for XPath

fn eq(&self, other: &Self) -> 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 Eq for XPath