Enum Error 

#[non_exhaustive]
pub enum Error {
    #[non_exhaustive]
    InvalidChar {
        index: usize,
        byte: u8,
    },
    #[non_exhaustive]
    OutputTooSmall {
        required: usize,
    },
    #[non_exhaustive]
    LengthMismatch {
        expected: usize,
        actual: usize,
    },
    OddLength,
    Overflow,
}

An error from checked hexadecimal encoding or decoding.

Slice conversions leave the entire destination unchanged on error. Each operation documents its validation order: for example, crate::hex_decode checks odd input length, destination capacity, then characters. A character check such as crate::hex_check returns a boolean instead of this type.

This enum and its data-bearing variants are non-exhaustive. Match fields using .. and keep a wildcard arm for future variants. Downstream crates cannot construct the non-exhaustive data-bearing variants directly.

Display and Debug provide diagnostics; their output is not a stable serialization format. Match variants and fields when handling errors programmatically. core::error::Error is implemented with every feature set.

Examples

use faster_hex::{hex_decode, Error};

let mut destination = [0; 1];
let error = hex_decode(b"0011", &mut destination).unwrap_err();
let required = match error {
    Error::OutputTooSmall { required, .. } => Some(required),
    _ => None,
};
assert_eq!(required, Some(2));

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.

#[non_exhaustive]

InvalidChar

The input contains a non-hex byte or a letter in a disallowed case.

Identifies the first invalid byte in source order, including for SIMD conversions. Non-ASCII and non-UTF-8 input is represented without loss.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

index: usize

The zero-based position of the first invalid byte in the supplied input.

This counts bytes, not Unicode characters or decoded output bytes.

byte: u8

The invalid byte, including a letter rejected by the case policy.

#[non_exhaustive]

OutputTooSmall

The destination cannot hold the complete output.

Used by slice conversion and fixed-capacity string encoding. Extra capacity is allowed; this error only indicates insufficient capacity.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

required: usize

The full required destination capacity in bytes, not the shortfall.

This is twice the input length for encoding and half the even input length for decoding.

#[non_exhaustive]

LengthMismatch

An array decoder’s input has the wrong decoded length.

Both shorter and longer inputs fail. This is distinct from OutputTooSmall, which allows spare capacity.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

expected: usize

The required array length, in decoded bytes.

actual: usize

The input length after dividing the even hex length by two.

OddLength

The hex input contains an odd number of bytes and cannot form byte pairs.

Decoders check this before capacity, exact length or character validity. Character-only checkers may still accept an odd-length input.

Overflow

The encoded length cannot be represented as a usize.

This is a length-arithmetic error, not an allocation-failure result.

Trait Implementations

impl Clone for Error

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Error

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Eq for Error

impl Error for Error

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

Available on crate feature defmt-03 only.

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl Hash for Error

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Error

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Error