Enum Error 

pub enum Error<I, E> {
    NonAscii,
    ChecksumMismatch {
        expected: u8,
        found: u8,
    },
    ParsingError(E),
    UnrecognizedMessage(I),
    InvalidField(I),
    Unknown,
}

Represents all possible errors that can occur during NMEA message parsing.

This enum covers various failure modes including input validation, checksum verification, and parsing errors.

Variants

NonAscii

The provided input contains non-ASCII characters.

NMEA messages must be ASCII-only for proper parsing and checksum calculation.

ChecksumMismatch

The checksum of the sentence was corrupt or incorrect.

Contains both the expected checksum (calculated from the message content) and the actual checksum found in the message.

Fields

expected: u8

The checksum calculated from the message content

found: u8

The checksum found in the message

ParsingError(E)

The sentence could not be parsed because its format was invalid.

This wraps nom’s standard parsing errors and provides context about what went wrong during parsing.

UnrecognizedMessage(I)

The message type is not recognized by the parser.

This variant is used when a valid NMEA sentence is encountered, but the parser does not implement handling for this specific message type. The message type that caused the error is provided for reference.

InvalidField(I)

A field in the NMEA sentence was invalid.

This error occurs when a specific field in the NMEA sentence does not conform to the expected format, type, or value range.

Contains the input that caused the error.

Unknown

An unknown error occurred.

This is a catch-all for unexpected error conditions.

Trait Implementations

impl<I: Debug, E: Debug> Debug for Error<I, E>

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

Formats the value using the given formatter.

impl<I, E, EX> FromExternalError<I, EX> for Error<I, E>

where E: FromExternalError<I, EX>,

fn from_external_error(input: I, kind: ErrorKind, e: EX) -> Self

Creates a new error from an input position, an ErrorKind indicating the wrapping parser, and an external error

impl<I, E> ParseError<I> for Error<I, E>

where E: ParseError<I>,

fn from_error_kind(input: I, kind: ErrorKind) -> Self

Creates an error from the input position and an ErrorKind

fn append(_: I, _: ErrorKind, other: Self) -> Self

Combines an existing error with a new one created from the input position and an ErrorKind. This is useful when backtracking through a parse tree, accumulating error context on the way

fn from_char(input: I, _: char) -> Self

Creates an error from an input position and an expected character

fn or(self, other: Self) -> Self

Combines two existing errors. This function is used to compare errors generated in various branches of alt.

impl<I: PartialEq, E: PartialEq> PartialEq for Error<I, E>

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