Enum PathError 

pub enum PathError {
    Parse(PathParseError),
    EmptyPath,
    NoRoot,
    TypeMismatch {
        at: String,
    },
    NotFound {
        at: String,
    },
    AliasRefused {
        at: String,
        alias: String,
    },
    IndexTooFar {
        at: String,
        len: usize,
        index: usize,
    },
    UndefinedAlias {
        at: String,
        alias: String,
    },
    InvalidMergeOperand {
        at: String,
        operand: String,
    },
}

Error returned by try_get_path / try_set_path / try_remove_path.

Distinguishes the several ways a path operation can fail so callers can react appropriately, instead of getting the previous silent no-op or ambiguous None.

Variants

Parse(PathParseError)

The path string is malformed; see PathParseError.

EmptyPath

The path is the empty string. Stray dots are a PathParseError::EmptySegment instead.

NoRoot

The receiver has no root value to descend into: Document was empty, or the requested operation needed a root mapping and the document’s root is a scalar / sequence.

TypeMismatch

A segment tried to descend into a value of the wrong container type – e.g. treating a scalar as a mapping in foo.bar when foo is a scalar. at is the segment index ("foo" in the example above) that led to the type mismatch.

Fields

at: String

The segment whose value was not the expected container type.

NotFound

The target segment does not exist. Applies to try_get_path and try_remove_path; try_set_path creates missing intermediates and never reports this. at is the missing segment.

Fields

at: String

The segment that could not be resolved.

AliasRefused

A segment landed on an alias (*name) and the active AliasPolicy refused to go through it. at is the segment, alias the anchor name it referenced.

Fields

at: String

The segment whose value is an alias.

alias: String

The anchor name the alias references, without the *.

IndexTooFar

Setting the requested index would have grown a sequence by more than MAX_INDEX_GROWTH null placeholders.

try_set_path("s[900000]", v) on a short sequence would otherwise pad it with that many entries, so a path from untrusted input could spend unbounded time and memory.

Fields

at: String

The segment whose index was out of reach.

len: usize

The current length of the sequence.

index: usize

The index that was asked for.

UndefinedAlias

A segment landed on an alias whose anchor is not defined anywhere in the document, so it could not be resolved. Also reported when a << merge operand consulted for the segment is such an alias.

Fields

at: String

The segment whose value is a dangling alias.

alias: String

The anchor name the alias references, without the *.

InvalidMergeOperand

Looking up a segment needed the mapping’s merge keys, and a << operand was neither a mapping nor an alias to one.

Fields

at: String

The segment being looked up.

operand: String

The source text of the offending operand.

Trait Implementations

impl Clone for PathError

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 PathError

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

Formats the value using the given formatter.

impl Display for PathError

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

Formats the value using the given formatter.

impl Eq for PathError

impl Error for PathError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<PathParseError> for PathError

fn from(e: PathParseError) -> Self

Converts to this type from the input type.

impl PartialEq for PathError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PathError