Enum ParseError

pub enum ParseError<'a> {
    DwordToUsize(Dword),
    InvalidFrameSize(Dword),
    InvalidChunkSize(Dword),
    Utf8Error(Utf8Error),
    PaletteError(PaletteError),
    InvalidFrameRange(Word, Word),
    LayerIndexOutOfBounds,
    InvalidPropertyType(Word),
    Nom(Error<&'a [u8]>),
}

Variants

DwordToUsize(Dword)

This variant is used when the conversion between DWORD (u32) to usize fails. The only way this can happen is when running this code on a 16-bit system.

InvalidFrameSize(Dword)

This variant is used when the frame size is <4

InvalidChunkSize(Dword)

This variant is used when the chunk size is <4

Utf8Error(Utf8Error)

This variant is used when a string does not contain valid UTF-8 data and str::from_utf8 returned an error.

PaletteError(PaletteError)

The uses index colors but the palette could not be generated due to errors in the palette chunks.

InvalidFrameRange(Word, Word)

The range of frame indices was invalid (from > to)

LayerIndexOutOfBounds

This variant is used when a layer index is out of bounds (layer_index >= layer_count)

InvalidPropertyType(Word)

This variant is used when a unsupported property type is found in the user data.

Nom(Error<&'a [u8]>)

This variant is used when the nom combinators return an error.

Trait Implementations

impl<'a> Debug for ParseError<'a>

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

Formats the value using the given formatter.

impl<'a> Display for ParseError<'a>

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

Formats the value using the given formatter.

impl<'a> Error for ParseError<'a>

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<'a> FromExternalError<&'a [u8], Utf8Error> for ParseError<'a>

fn from_external_error(_input: &'a [u8], _kind: ErrorKind, e: Utf8Error) -> Self

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

impl<'a> ParseError<&'a [u8]> for ParseError<'a>

fn from_error_kind(input: &'a [u8], kind: ErrorKind) -> Self

Creates an error from the input position and an ErrorKind

fn append(_input: &[u8], _kind: 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.