Enum ProcessError 

pub enum ProcessError {
    Processing(String),
    Parameter(String),
    InvalidPort(String),
    Buffer(String),
    NodeNotFound(u32),
    PortNotFound(String),
    Connection(String),
    TypeMismatch {
        expected: &'static str,
        got: &'static str,
    },
    SampleRateMismatch {
        expected: f32,
        got: f32,
    },
    Config(String),
    NotInitialized,
    AlreadyInitialized,
    Unsupported(String),
    Timeout,
    RealtimeViolation(String),
    Internal(String),
}

Main error type for signal processing operations

This error can occur during node processing, parameter changes, or any other operation in the signal graph.

Variants

Processing(String)

Error during signal processing

Parameter(String)

Error with a parameter (invalid value, out of range, etc.)

InvalidPort(String)

Invalid port access

Buffer(String)

Buffer operation failed

NodeNotFound(u32)

Node not found

PortNotFound(String)

Port not found

Connection(String)

Connection error

TypeMismatch

Type mismatch (e.g., trying to connect audio to control)

Fields

expected: &'static str

Expected type

got: &'static str

Actual type

SampleRateMismatch

Sample rate mismatch

Fields

expected: f32

Expected sample rate

got: f32

Actual sample rate

Config(String)

Configuration error

NotInitialized

Not initialized

AlreadyInitialized

Already initialized

Unsupported(String)

Unsupported operation

Timeout

Timeout occurred

RealtimeViolation(String)

Real-time violation — operation exceeded its time budget or performed an illegal action (allocation, blocking, etc.)

Internal(String)

Internal error (for implementation-specific errors)

Implementations

impl ProcessError

pub fn processing(msg: impl Into<String>) -> ProcessError

Create a new processing error with a formatted message

pub fn parameter(msg: impl Into<String>) -> ProcessError

Create a new parameter error with a formatted message

pub fn invalid_port(port: impl Display) -> ProcessError

Create a new invalid port error

pub fn buffer(msg: impl Into<String>) -> ProcessError

Create a new buffer error

pub fn node_not_found(id: u32) -> ProcessError

Create a new node not found error

pub fn port_not_found(port: impl Display) -> ProcessError

Create a new port not found error

pub fn connection(msg: impl Into<String>) -> ProcessError

Create a new connection error

pub fn type_mismatch(expected: &'static str, got: &'static str) -> ProcessError

Create a new type mismatch error

pub fn sample_rate_mismatch(expected: f32, got: f32) -> ProcessError

Create a new sample rate mismatch error

pub fn config(msg: impl Into<String>) -> ProcessError

Create a new configuration error

pub fn unsupported(msg: impl Into<String>) -> ProcessError

Create a new unsupported operation error

pub fn internal(msg: impl Into<String>) -> ProcessError

Create a new internal error

pub fn is_recoverable(&self) -> bool

Check if this error is recoverable

Recoverable errors are those that don’t require stopping the signal thread, such as temporary buffer underflows or parameter errors.

pub fn code(&self) -> &'static str

Get a short error code for this error (useful for logging)

Trait Implementations

impl Clone for ProcessError

fn clone(&self) -> ProcessError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessError

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

Formats the value using the given formatter.

impl Display for ProcessError

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

Formats the value using the given formatter.

impl Error for ProcessError

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<ClockError> for ProcessError

fn from(err: ClockError) -> ProcessError

Converts to this type from the input type.

impl From<ConnectionError> for ProcessError

fn from(err: ConnectionError) -> ProcessError

Converts to this type from the input type.

impl From<Error> for ProcessError

fn from(err: Error) -> ProcessError

Converts to this type from the input type.

impl From<Error> for ProcessError

fn from(err: Error) -> ProcessError

Converts to this type from the input type.

impl From<ParameterError> for ProcessError

fn from(err: ParameterError) -> ProcessError

Converts to this type from the input type.

impl From<PortError> for ProcessError

fn from(err: PortError) -> ProcessError

Converts to this type from the input type.

impl PartialEq for ProcessError

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