Struct Path 

pub struct Path { /* private fields */ }

A path from the document root to a node.

A flat list of segments: no recursion anywhere in its impls.

use oneyaml_core::{Path, PathSegment};

let p = Path::new().with_key("spec").with_key("ports").with_index(2);
assert_eq!(p.to_string(), "spec.ports[2]");
assert_eq!(p.segments().last(), Some(&PathSegment::Index(2)));
let mut q = p.clone();
q.push_key("port");
assert_eq!((q.len(), q.pop()), (4, Some(PathSegment::Key("port".into()))));
q.push_index(0);
assert_eq!(q.to_string(), "spec.ports[2][0]");
assert!(!q.is_empty() && Path::new().is_empty());

Implementations

impl Path

pub const fn new() -> Self

The root path (no segments).

pub fn push_key(&mut self, key: impl Into<String>)

Appends a mapping-key segment.

pub fn push_index(&mut self, index: usize)

Appends a sequence-index segment.

pub fn with_key(self, key: impl Into<String>) -> Self

Chainable Path::push_key.

pub fn with_index(self, index: usize) -> Self

Chainable Path::push_index.

pub fn pop(&mut self) -> Option<PathSegment>

Removes and returns the last segment.

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

The segments, root first.

pub fn is_empty(&self) -> bool

true for the root path.

pub fn len(&self) -> usize

Number of segments.

impl Path

pub fn parse(s: &str) -> Result<Path, ParsePathError>

Parses a path string: the inverse of Display, so Path::parse(&p.to_string()) == Ok(p) for every path.

The syntax:

• keys are separated by .: spec.template.metadata;
• [n] (decimal digits) is a sequence index: containers[0], [0] at the start, m[1][2] for nested sequences;
• a key holding ., [, ], ", \, white space or a control character, or an empty key, is written in double quotes, where \" is a quote, \\ a backslash and \u{hex} any character: a."b.c"[0], "" (the empty key), "say \"hi\"";
• . alone is the root path (what Display writes for it); the empty string is an error, so an empty key from user input never names the whole document.

Every key is text: [n] is always an index, and a.1 is the key "1".

use oneyaml_core::{Path, path};

let p = Path::parse("spec.containers[0].\"app.kubernetes.io/name\"").unwrap();
assert_eq!(p, path!["spec", "containers", 0, "app.kubernetes.io/name"]);
assert_eq!(Path::parse(&p.to_string()), Ok(p));
assert_eq!(Path::parse("."), Ok(Path::new()));
assert_eq!(
    Path::parse("").unwrap_err().reason(),
    "an empty path: write `.` for the root"
);
let err = Path::parse("a..b").unwrap_err();
assert_eq!(err.offset(), 2);
assert_eq!(err.reason(), "expected a key after `.`");

Errors

ParsePathError, with the byte offset and the reason, for anything else: the empty string, an empty segment (a..b, a., .a), a bare key with a reserved character (a b, a]), an unclosed quote or [, a non-digit or overflowing index, an unknown escape, or text right after a quoted key or an index ("a"b, [0]x).

Trait Implementations

impl Clone for Path

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl Default for Path

fn default() -> Self

Returns the “default value” for a type.

impl Display for Path

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

a.b[2].c; keys that are empty or contain .[]"\, whitespace, or control characters are written as "…" with \"/\\ escaped; the root path is written as ..

impl Eq for Path

impl FromStr for Path

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

As Path::parse.

type Err = ParsePathError

The associated error which can be returned from parsing.

impl Hash for Path

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 Path

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Path