Struct ParsedPath 

pub struct ParsedPath { /* private fields */ }

Implementations

impl ParsedPath

pub fn parse(input: &str) -> Result<Self, PathParseError>

Examples found in repository

examples/plural_selectors.rs (line 40)

fn run() -> Result<(), Box<dyn std::error::Error>> {
    let mut me = Kernel::new();

    me.postulate("apps.demo.notes[alpha].title", "Alpha")?;
    me.postulate("apps.demo.notes[beta].title", "Beta")?;
    me.postulate("apps.demo.notes[beta].tags.primary", "work")?;

    assert_eq!(
        me.children("apps.demo.notes[]")?,
        vec!["alpha".to_string(), "beta".to_string()]
    );

    assert_eq!(
        me.read_public_subtree("apps.demo.notes[]")?,
        Some(object([
            ("alpha", object([("title", Value::from("Alpha"))])),
            (
                "beta",
                object([
                    ("tags", object([("primary", Value::from("work"))])),
                    ("title", Value::from("Beta")),
                ]),
            ),
        ]))
    );

    let parsed = ParsedPath::parse("apps.demo.notes[priority >= 2]")?;
    assert_eq!(
        parsed.normalized(),
        vec![
            "apps".to_string(),
            "demo".to_string(),
            "notes".to_string(),
            "priority >= 2".to_string(),
        ]
    );

    println!("notes[] members = {:?}", me.children("apps.demo.notes[]")?);
    Ok(())
}

pub fn parts(&self) -> &[PathPart]

pub fn normalized(&self) -> Path

Examples found in repository

examples/plural_selectors.rs (line 42)

fn run() -> Result<(), Box<dyn std::error::Error>> {
    let mut me = Kernel::new();

    me.postulate("apps.demo.notes[alpha].title", "Alpha")?;
    me.postulate("apps.demo.notes[beta].title", "Beta")?;
    me.postulate("apps.demo.notes[beta].tags.primary", "work")?;

    assert_eq!(
        me.children("apps.demo.notes[]")?,
        vec!["alpha".to_string(), "beta".to_string()]
    );

    assert_eq!(
        me.read_public_subtree("apps.demo.notes[]")?,
        Some(object([
            ("alpha", object([("title", Value::from("Alpha"))])),
            (
                "beta",
                object([
                    ("tags", object([("primary", Value::from("work"))])),
                    ("title", Value::from("Beta")),
                ]),
            ),
        ]))
    );

    let parsed = ParsedPath::parse("apps.demo.notes[priority >= 2]")?;
    assert_eq!(
        parsed.normalized(),
        vec![
            "apps".to_string(),
            "demo".to_string(),
            "notes".to_string(),
            "priority >= 2".to_string(),
        ]
    );

    println!("notes[] members = {:?}", me.children("apps.demo.notes[]")?);
    Ok(())
}

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

Formats the value using the given formatter.

impl Eq for ParsedPath

impl PartialEq for ParsedPath

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParsedPath