Enum CodecDecodeError 

pub enum CodecDecodeError<E> {
    Decode {
        source: E,
        input_index: usize,
    },
    Incomplete {
        input_index: usize,
        required_total: usize,
        available: usize,
    },
    TrailingInput {
        consumed: usize,
        remaining: usize,
    },
    InvalidInputIndex {
        index: usize,
        len: usize,
    },
    InvalidOutputIndex {
        index: usize,
        len: usize,
    },
    InsufficientOutput {
        output_index: usize,
        required: usize,
        available: usize,
    },
}

Error reported by codec-backed value and buffered decoder adapters.

The wrapped codec remains responsible for domain-specific decode failures. This type adds adapter-level failures that cannot be represented by the wrapped codec itself, such as a value decoder receiving too few units before it can safely call crate::Codec::decode or a buffered decoder receiving an invalid output start index.

Variants

Decode

The wrapped codec reported a decode error.

Fields

source: E

Error returned by the wrapped codec.

input_index: usize

Absolute input index at which the adapter called the wrapped codec.

Incomplete

The adapter could not safely call the wrapped codec because input ended.

Fields

input_index: usize

Absolute input index where the incomplete value starts.

required_total: usize

Total units required from input_index.

available: usize

Units available from input_index.

TrailingInput

A whole-value decode succeeded but left trailing input units.

Fields

consumed: usize

Units consumed by the decoded value.

remaining: usize

Extra units left after the decoded value.

InvalidInputIndex

The caller supplied an input index outside the input slice.

Fields

index: usize

Invalid input index supplied by the caller.

len: usize

Length of the input slice.

InvalidOutputIndex

The caller supplied an output index outside the output slice.

Fields

index: usize

Invalid output index supplied by the caller.

len: usize

Length of the output slice.

InsufficientOutput

The output slice cannot hold all output required by the adapter call.

Fields

output_index: usize

Absolute output index where writing would start.

required: usize

Output units required from output_index.

available: usize

Output units available from output_index.

Implementations

impl<E> CodecDecodeError<E>

pub const fn decode(source: E, input_index: usize) -> Self

Creates an error wrapping a codec-specific decode error.

Parameters

• source: Error returned by the wrapped codec.
• input_index: Absolute input index used for the codec call.

Returns

Returns a codec decode error wrapper.

pub const fn incomplete( input_index: usize, required_total: usize, available: usize, ) -> Self

Creates an adapter-level incomplete-input error.

Parameters

• input_index: Absolute input index where the incomplete value starts.
• required_total: Total units required from input_index.
• available: Units available from input_index.

Returns

Returns an incomplete-input error.

pub const fn trailing_input(consumed: usize, remaining: usize) -> Self

Creates a trailing-input error for whole-value decoding.

Parameters

• consumed: Units consumed by the decoded value.
• remaining: Extra units left after the decoded value.

Returns

Returns a trailing-input error.

pub const fn invalid_input_index(index: usize, len: usize) -> Self

Creates an invalid-input-index error.

Parameters

• index: Invalid input index supplied by the caller.
• len: Length of the input slice.

Returns

Returns an invalid-input-index error.

pub const fn invalid_output_index(index: usize, len: usize) -> Self

Creates an invalid-output-index error.

Parameters

• index: Invalid output index supplied by the caller.
• len: Length of the output slice.

Returns

Returns an invalid-output-index error.

pub const fn insufficient_output( output_index: usize, required: usize, available: usize, ) -> Self

Creates an insufficient-output error.

pub const fn is_incomplete(&self) -> bool

Returns whether this error indicates an incomplete input prefix.

Returns

Returns true only for the Incomplete variant.

pub fn needed_additional(&self) -> Option<NonZeroUsize>

Returns the additional input units needed to make progress.

This is a convenience accessor over the Incomplete variant’s fields. Streaming callers can use it to determine how many more units they must buffer before retrying a decode.

Returns

Returns Some(needed) for Incomplete errors, where needed is the strictly positive difference between the minimum units required and those already available. Returns None for all other variants.

pub fn ensure_input_index( input_len: usize, input_index: usize, ) -> Result<(), Self>

Validates that input_index is within an input slice.

Parameters

• input_len: Length of the input slice.
• input_index: Input index supplied by the caller.

Returns

Returns Ok(()) when input_index <= input_len.

Errors

Returns an invalid-input-index error when input_index is beyond the slice.

pub fn ensure_output_index( output_len: usize, output_index: usize, ) -> Result<(), Self>

Validates that output_index is within an output slice.

Parameters

• output_len: Length of the output slice.
• output_index: Output index supplied by the caller.

Returns

Returns Ok(()) when output_index <= output_len.

Errors

Returns an invalid-output-index error when output_index is beyond the slice.

pub fn ensure_output_capacity( output_len: usize, output_index: usize, required: usize, ) -> Result<(), Self>

Validates that an output slice can hold required adapter output.

Parameters

• output_len: Length of the output slice.
• output_index: Output index supplied by the caller.
• required: Output units required from output_index.

Returns

Returns Ok(()) when output capacity is sufficient.

Errors

Returns an invalid-output-index error when output_index is beyond the slice, or an insufficient-output error when fewer than required units are writable from output_index.

pub fn ensure_min_input( input_len: usize, input_index: usize, min_required: usize, ) -> Result<(), Self>

Validates that enough input units are available from input_index.

Parameters

• input_len: Length of the input slice.
• input_index: Absolute input index where reading starts.
• min_required: Minimum units required from input_index.

Returns

Returns Ok(()) when at least min_required units are available.

Errors

Returns an incomplete-input error when fewer than min_required units are available from input_index.

pub fn ensure_no_trailing_input( consumed: usize, total: usize, ) -> Result<(), Self>

Validates that decoding consumed the entire input slice.

Parameters

• consumed: Units consumed by the decoded value.
• total: Total units in the input slice.

Returns

Returns Ok(()) when consumed == total.

Errors

Returns a trailing-input error when extra units remain after the decoded value.

Trait Implementations

impl<E: Clone> Clone for CodecDecodeError<E>

fn clone(&self) -> CodecDecodeError<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Copy> Copy for CodecDecodeError<E>

impl<E: Debug> Debug for CodecDecodeError<E>

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

Formats the value using the given formatter.

impl<E> Display for CodecDecodeError<E>

where E: Display,

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

Formats the value using the given formatter.

impl<E: Eq> Eq for CodecDecodeError<E>

impl<E> Error for CodecDecodeError<E>

where E: Error + 'static, Self: Debug + Display,

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<E: Hash> Hash for CodecDecodeError<E>

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<E: PartialEq> PartialEq for CodecDecodeError<E>

fn eq(&self, other: &CodecDecodeError<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<E: PartialEq> StructuralPartialEq for CodecDecodeError<E>