Enum Error 

pub enum Error<'a> {
    OutOfMemory,
    QueueSendTimeout,
    QueueReceiveTimeout,
    MutexTimeout,
    MutexLockFailed,
    Timeout,
    QueueFull,
    StringConversionError,
    TaskNotFound,
    InvalidQueueSize,
    NullPtr,
    NotFound,
    OutOfIndex,
    InvalidType,
    Empty,
    WriteError(&'a str),
    ReadError(&'a str),
    ReturnWithCode(i32),
    Unhandled(&'a str),
    UnhandledOwned(String),
}

Error types for OSAL-RS operations.

Represents all possible error conditions that can occur when using the OSAL-RS library.

Lifetime Parameter

The error type is generic over lifetime 'a to allow flexible error messages. Most of the time, you can use the default Result<T> type alias which uses Error<'static>. For custom lifetimes in error messages, use core::result::Result<T, Error<'a>> explicitly.

Examples

Basic usage with static errors

use osal_rs::os::{Queue, QueueFn};
use osal_rs::utils::Error;
 
match Queue::new(10, 32) {
    Ok(queue) => { /* use queue */ },
    Err(Error::OutOfMemory) => println!("Failed to allocate queue"),
    Err(e) => println!("Other error: {:?}", e),
}

Using borrowed error messages

use osal_rs::utils::Error;
 
fn validate_input(input: &str) -> core::result::Result<(), Error> {
    if input.is_empty() {
        // Use static lifetime for compile-time strings
        Err(Error::Unhandled("Input cannot be empty"))
    } else {
        Ok(())
    }
}
 
// For dynamic error messages from borrowed data
fn process_data<'a>(data: &'a str) -> core::result::Result<(), Error<'a>> {
    if !data.starts_with("valid:") {
        // Error message borrows from 'data' lifetime
        Err(Error::ReadError(data))
    } else {
        Ok(())
    }
}

Variants

OutOfMemory

Insufficient memory to complete operation

QueueSendTimeout

Queue send operation timed out

QueueReceiveTimeout

Queue receive operation timed out

MutexTimeout

Mutex operation timed out

MutexLockFailed

Failed to acquire mutex lock

Timeout

Generic timeout error

QueueFull

Queue is full and cannot accept more items

StringConversionError

String conversion failed

TaskNotFound

Thread/task not found

InvalidQueueSize

Invalid queue size specified

NullPtr

Null pointer encountered

NotFound

Requested item not found

OutOfIndex

Index out of bounds

InvalidType

Invalid type for operation

Empty

No data available

WriteError(&'a str)

Write error occurred

ReadError(&'a str)

Read error occurred

ReturnWithCode(i32)

Return error with code

Unhandled(&'a str)

Unhandled error with description

UnhandledOwned(String)

Unhandled error with description owned

Trait Implementations

impl<'a> Clone for Error<'a>

fn clone(&self) -> Error<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Error<'a>

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

Formats the value using the given formatter.

impl<'a> Display for Error<'a>

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

Formats the error for display.

Provides human-readable error messages suitable for logging or presentation to users.

impl<'a> Hash for Error<'a>

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<'a> PartialEq for Error<'a>

fn eq(&self, other: &Error<'a>) -> 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<'a> Eq for Error<'a>

impl<'a> StructuralPartialEq for Error<'a>