Enum ProcessingError 

#[non_exhaustive]
pub enum ProcessingError {
    MathematicalFailure {
        operation: String,
        reason: String,
    },
    AlgorithmFailure {
        algorithm: String,
        reason: String,
    },
    InsufficientData {
        operation: String,
        reason: String,
    },
    ConvergenceFailure {
        algorithm: String,
        iterations: u32,
    },
    ExternalDependency {
        dependency: String,
        operation: String,
        reason: String,
    },
}

Errors that occur during audio processing operations.

Purpose

Covers failures in DSP algorithms, mathematical operations, and other processing-specific issues that don’t belong in the conversion, parameter, or layout domains.

Intended Usage

Return these errors when a processing algorithm cannot complete successfully. Use MathematicalFailure for arithmetic issues, AlgorithmFailure for general algorithm errors, and ConvergenceFailure when an iterative algorithm exhausts its iteration budget.

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.

MathematicalFailure

A mathematical operation failed due to invalid input or numerical issues.

Fields

operation: String

The mathematical operation that failed.

reason: String

Detailed explanation of the mathematical failure.

AlgorithmFailure

An audio processing algorithm encountered an error during execution.

Fields

algorithm: String

The processing algorithm that failed.

reason: String

Detailed explanation of the algorithm failure.

InsufficientData

The operation failed due to insufficient data or resources.

Fields

operation: String

The operation that requires more data.

reason: String

Explanation of the data requirements.

ConvergenceFailure

A convergence-based algorithm failed to converge within limits.

Fields

algorithm: String

The algorithm that failed to converge.

iterations: u32

Number of iterations attempted.

ExternalDependency

An external dependency or resource required for processing is unavailable.

Fields

dependency: String

The external dependency that’s unavailable.

operation: String

The operation that requires the dependency.

reason: String

Reason why the dependency is unavailable.

Implementations

impl ProcessingError

pub fn algorithm_failure<A, R>(algorithm: A, reason: R) -> Self

where A: ToString, R: ToString,

Creates a ProcessingError::AlgorithmFailure error.

Use this when a DSP or signal-processing algorithm cannot complete successfully for reasons intrinsic to the algorithm itself, such as filter instability or a failed FFT plan.

Arguments

• algorithm — Name of the processing algorithm that failed.
• reason — Human-readable explanation of what went wrong.

Returns

A ProcessingError::AlgorithmFailure variant.

Examples

use audio_samples::ProcessingError;

let err = ProcessingError::algorithm_failure("butterworth", "filter became unstable");
assert!(matches!(err, ProcessingError::AlgorithmFailure { .. }));

Trait Implementations

impl Clone for ProcessingError

fn clone(&self) -> ProcessingError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessingError

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

Formats the value using the given formatter.

impl Display for ProcessingError

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

Formats the value using the given formatter.

impl Error for ProcessingError

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 From<&str> for ProcessingError

fn from(msg: &str) -> Self

Converts to this type from the input type.

impl From<ProcessingError> for AudioSampleError

fn from(source: ProcessingError) -> Self

Converts to this type from the input type.

impl From<String> for ProcessingError

fn from(msg: String) -> Self

Converts to this type from the input type.