Enum FinishError 

pub enum FinishError<E> {
    Capacity {
        source: CapacityError,
    },
    InvalidOutputIndex {
        index: usize,
        len: usize,
    },
    InsufficientOutput {
        output_index: usize,
        required: usize,
        available: usize,
    },
    Source {
        source: E,
    },
}

Error reported by one-shot buffered finalization.

finish methods require enough output capacity to write all final output in one call. This type separates caller capacity mistakes from semantic errors reported by the concrete codec or hook policy.

Variants

Capacity

Finish-output bound arithmetic overflowed.

Fields

source: CapacityError

Capacity planning error.

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 final output.

Fields

output_index: usize

Absolute output index where finalization would start writing.

required: usize

Output units required to finish in one call.

available: usize

Output units available from output_index.

Source

The underlying codec or hook policy rejected finalization.

Fields

source: E

Error returned by the concrete codec or hook policy.

Implementations

impl<E> FinishError<E>

pub const fn capacity(source: CapacityError) -> Self

Creates a finish error from capacity planning failure.

Parameters

• source: Capacity planning error reported while computing the finish bound.

Returns

Returns a finish error wrapping source.

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

Creates an invalid-output-index finish error.

Parameters

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

Returns

Returns an invalid-output-index finish error.

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

Creates an insufficient-output finish error.

Parameters

• output_index: Output index supplied by the caller.
• required: Output units required to finish in one call.
• available: Output units available from output_index.

Returns

Returns an insufficient-output finish error.

pub const fn source(source: E) -> Self

Creates a finish error from an underlying semantic error.

Parameters

• source: Error returned by the concrete codec or hook policy.

Returns

Returns a finish error wrapping source.

pub fn map_source<T, F>(self, map: F) -> FinishError<T>

where F: FnOnce(E) -> T,

Maps the underlying semantic error while preserving capacity failures.

Type Parameters

• T: Target semantic error type.
• F: Mapping function type.

Parameters

• map: Function used to map the underlying semantic error.

Returns

Returns a finish error with the mapped semantic error type.

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

Validates that an output slice can hold one-shot final output.

Parameters

• output_len: Length of the output slice.
• output_index: Output index supplied by the caller.
• required: Output units required to finish in one call.

Returns

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

Errors

Returns FinishError::InvalidOutputIndex when output_index is beyond the slice, or FinishError::InsufficientOutput when fewer than required units are writable from output_index.

Trait Implementations

impl<E: Clone> Clone for FinishError<E>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Copy> Copy for FinishError<E>

impl<E: Debug> Debug for FinishError<E>

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

Formats the value using the given formatter.

impl<E> Display for FinishError<E>

where E: Display,

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

Formats the value using the given formatter.

impl<E: Eq> Eq for FinishError<E>

impl<E> Error for FinishError<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 FinishError<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 FinishError<E>

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