Enum ReplaceError 

pub enum ReplaceError {
    OpenTooDeep,
    InconsistentOpenDepths,
    CannotJoin {
        onto: String,
        joined: String,
    },
    InvalidContent {
        parent: String,
    },
    Position {
        pos: usize,
        max: usize,
    },
}

Why a Node::replace could not be performed.

Variants

OpenTooDeep

The slice’s open depth exceeds the insertion position’s depth.

InconsistentOpenDepths

from’s and to’s open depths are inconsistent with the slice.

CannotJoin

Two nodes that would have to be joined have incompatible content.

Fields

onto: String

The node type being joined on.

joined: String

The node type being joined.

InvalidContent

The resulting content would violate the schema for parent.

Fields

parent: String

The parent node type whose content became invalid.

Position

A boundary position was out of range.

Fields

pos: usize

The offending position.

max: usize

The maximum valid position.

Trait Implementations

impl Clone for ReplaceError

fn clone(&self) -> ReplaceError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReplaceError

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

Formats the value using the given formatter.

impl Display for ReplaceError

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

Formats the value using the given formatter.

impl Eq for ReplaceError

impl Error for ReplaceError

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

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