Enum ParseMentionErrorType 

#[non_exhaustive]
pub enum ParseMentionErrorType<'a> {
    IdNotU64 {
        found: &'a str,
    },
    ExtraneousPart {
        found: &'a str,
    },
    LeadingArrow {
        found: Option<char>,
    },
    PartMissing {
        expected: usize,
        found: usize,
    },
    Sigil {
        expected: &'a [&'a str],
        found: Option<char>,
    },
    TimestampStyleInvalid {
        found: &'a str,
    },
    TrailingArrow {
        found: Option<char>,
    },
}

Type of ParseMentionError that occurred.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

IdNotU64

ID portion of the mention isn’t a u64.

Fields

found: &'a str

String that could not be parsed into a u64.

ExtraneousPart

An extra part was found that shouldn’t be present.

Fields

found: &'a str

The extra part that was found.

LeadingArrow

Leading arrow (<) is not present.

Fields

found: Option<char>

Character that was instead found where the leading arrow should be.

PartMissing

One or more parts of the mention are missing.

For example, an emoji mention - <:name:id> - has two parts: the name and the id, separated by the sigil (:). If the second sigil denoting the second part can’t be found, then it is missing.

Fields

expected: usize

Number of parts that are expected.

found: usize

Number of parts that have been found.

Sigil

Mention’s sigil is not present.

Users, for example, have the sigil @.

Fields

expected: &'a [&'a str]

Possible sigils that were expected for the mention type.

found: Option<char>

Character that was instead found where the sigil should be.

TimestampStyleInvalid

Timestamp style value is invalid.

Fields

found: &'a str

Value of the style.

TrailingArrow

Trailing arrow (>) is not present.

Fields

found: Option<char>

Character that was instead found where the trailing arrow should be.

Trait Implementations

impl<'a> Debug for ParseMentionErrorType<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for ParseMentionErrorType<'a>

impl<'a> PartialEq for ParseMentionErrorType<'a>

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