Enum ParseTreeError 

pub enum ParseTreeError {
    Checksum(Error),
    MaxRecursionDepthExceeded {
        actual: usize,
        maximum: u32,
    },
    ExpectedParenOrComma {
        ch: char,
        pos: usize,
    },
    UnmatchedOpenParen {
        ch: char,
        pos: usize,
    },
    UnmatchedCloseParen {
        ch: char,
        pos: usize,
    },
    MismatchedParens {
        open_ch: char,
        open_pos: usize,
        close_ch: char,
        close_pos: usize,
    },
    IncorrectName {
        actual: String,
        expected: &'static str,
    },
    IncorrectNumberOfChildren {
        description: &'static str,
        n_children: usize,
        minimum: Option<usize>,
        maximum: Option<usize>,
    },
    IllegalCurlyBrace {
        pos: usize,
    },
    MultipleSeparators {
        separator: char,
        pos: usize,
    },
    TrailingCharacter {
        ch: char,
        pos: usize,
    },
    UnknownName {
        name: String,
    },
}

An error parsing an expression tree.

Variants

Checksum(Error)

Error validating the checksum or character set.

MaxRecursionDepthExceeded

Expression tree had depth exceeding our hard cap.

Fields

actual: usize

The depth of the tree that was attempted to be parsed.

maximum: u32

The maximum depth.

ExpectedParenOrComma

After a close-paren, the only valid next characters are close-parens and commas. Got something else.

Fields

ch: char

What we got instead.

pos: usize

Its byte-index into the string.

UnmatchedOpenParen

An open-parenthesis had no corresponding close-parenthesis.

Fields

ch: char

The character in question (‘(’ or ‘{’)

pos: usize

Its byte-index into the string.

UnmatchedCloseParen

A close-parenthesis had no corresponding open-parenthesis.

Fields

ch: char

The character in question (‘)’ or ‘}’)

pos: usize

Its byte-index into the string.

MismatchedParens

A ( was matched with a } or vice-versa.

Fields

open_ch: char

The opening parenthesis (‘(’ or ‘{’)

open_pos: usize

The position of the opening parethesis.

close_ch: char

The closing parenthesis (‘)’ or ‘}’)

close_pos: usize

The position of the closing parethesis.

IncorrectName

A node had the wrong name.

Fields

actual: String

The name that was found.

expected: &'static str

The name that was expected.

IncorrectNumberOfChildren

A node had the wrong number of children.

Fields

description: &'static str

A description of the node in question.

n_children: usize

The number of children the node had.

minimum: Option<usize>

The minimum of children the node should have had.

maximum: Option<usize>

The minimum of children the node should have had.

IllegalCurlyBrace

A Taproot child occurred somewhere it was not allowed.

Fields

pos: usize

The position of the opening curly brace.

MultipleSeparators

Multiple separators (‘:’ or ‘@’) appeared in a node name.

Fields

separator: char

The separator in question.

pos: usize

The position of the second separator.

TrailingCharacter

Data occurred after the final ).

Fields

ch: char

The first trailing character.

pos: usize

Its byte-index into the string.

UnknownName

A node’s name was not recognized.

Fields

name: String

The name that was not recognized.

Trait Implementations

impl Debug for ParseTreeError

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

Formats the value using the given formatter.

impl Display for ParseTreeError

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

Formats the value using the given formatter.

impl Error for ParseTreeError

Available on crate feature std only.

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<Error> for ParseTreeError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<ParseTreeError> for ParseError

fn from(e: ParseTreeError) -> Self

Converts to this type from the input type.

impl PartialEq for ParseTreeError

fn eq(&self, other: &ParseTreeError) -> 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 ParseTreeError

impl StructuralPartialEq for ParseTreeError