Enum LayoutError 

#[non_exhaustive]
pub enum LayoutError {
    NonContiguous {
        operation: String,
        layout_type: String,
    },
    DimensionMismatch {
        expected_dims: String,
        actual_dims: String,
        operation: String,
    },
    BorrowedDataMutation {
        operation: String,
        reason: String,
    },
    IncompatibleFormat {
        operation: String,
        reason: String,
    },
    ShapeError {
        operation: String,
        info: String,
    },
    InvalidOperation(String, String),
}

Errors related to memory layout, array structure, and data organization.

Purpose

Covers failures related to array contiguity, dimension mismatches, borrowed data mutation attempts, and other structural issues that arise from the ndarray-backed storage of audio samples.

Intended Usage

Return these errors when an operation’s structural preconditions are not met — for example, when a mono-only function receives multi-channel input, or when an in-place operation is attempted on borrowed (non-owned) data.

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.

NonContiguous

Array data is not contiguous in memory when contiguous layout is required.

Fields

operation: String

The operation that requires contiguous layout.

layout_type: String

Description of the actual layout (e.g., “strided”, “non-standard order”).

DimensionMismatch

Array dimensions don’t match expected values for the operation.

Fields

expected_dims: String

Description of expected dimensions.

actual_dims: String

Description of actual dimensions.

operation: String

The operation that has dimension requirements.

BorrowedDataMutation

Attempted to modify borrowed audio data that should be immutable.

Fields

operation: String

The operation that attempted to modify borrowed data.

reason: String

Explanation of why modification is not allowed.

IncompatibleFormat

Data size or format is incompatible with the operation requirements.

Fields

operation: String

The operation with format requirements.

reason: String

Detailed explanation of the format incompatibility.

ShapeError

A shape-related error occurred during array operations.

Fields

operation: String

The operation that encountered the shape error.

info: String

Detailed information about the shape error.

InvalidOperation(String, String)

Error indicating an invalid operation on audio data.

Occurs when attempting an operation that violates preconditions, such as applying a function to incompatible audio layouts, mismatched dimensions, or invalid state.

Implementations

impl LayoutError

pub fn invalid_operation<S>(operation: S, reason: S) -> Self

where S: ToString,

Creates a LayoutError::InvalidOperation error.

Use this when a valid operation is called in a context where it cannot proceed — for example, requesting an STFT on multi-channel audio.

Arguments

• operation — Name of the operation that was called in an invalid context.
• reason — Human-readable explanation of why the operation cannot proceed (e.g. "STFT requires mono audio").

Returns

LayoutError::InvalidOperation(operation.to_string(), reason.to_string()).

Examples

use audio_samples::LayoutError;

let err = LayoutError::invalid_operation("stft", "requires mono audio");
assert!(matches!(err, LayoutError::InvalidOperation(_, _)));

impl LayoutError

pub fn borrowed_mutation<O, R>(operation: O, reason: R) -> Self

where O: ToString, R: ToString,

Creates a LayoutError::BorrowedDataMutation error.

Use this when an in-place or mutating operation is attempted on audio data that is held via an immutable borrow and therefore cannot be modified.

Arguments

• operation — Name of the operation that attempted to modify borrowed data.
• reason — Human-readable explanation of why modification is not allowed.

Returns

A LayoutError::BorrowedDataMutation variant.

Examples

use audio_samples::LayoutError;

let err = LayoutError::borrowed_mutation("normalize_in_place", "audio data is borrowed");
assert!(matches!(err, LayoutError::BorrowedDataMutation { .. }));

pub fn dimension_mismatch<E, A, O>(expected: E, actual: A, operation: O) -> Self

where E: ToString, A: ToString, O: ToString,

Creates a LayoutError::DimensionMismatch error.

Use this when an array or buffer has the wrong number of dimensions or an unexpected shape for the operation being performed.

Arguments

• expected — Description of the expected dimensions (e.g. "(1, 1024)").
• actual — Description of the actual dimensions received (e.g. "(2, 1024)").
• operation — Name of the operation that has the dimension requirement.

Returns

A LayoutError::DimensionMismatch variant.

Examples

use audio_samples::LayoutError;

let err = LayoutError::dimension_mismatch("(1, 1024)", "(2, 1024)", "mono_fft");
assert!(matches!(err, LayoutError::DimensionMismatch { .. }));

Trait Implementations

impl Clone for LayoutError

fn clone(&self) -> LayoutError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LayoutError

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

Formats the value using the given formatter.

impl Display for LayoutError

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

Formats the value using the given formatter.

impl Error for LayoutError

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<LayoutError> for AudioSampleError

fn from(source: LayoutError) -> Self

Converts to this type from the input type.