Struct RawMutex 

pub struct RawMutex(/* private fields */);

Mutex types and guards for mutual exclusion. Low-level POSIX mutex: lock/unlock only, no guarded data and no RAII guard. Most application code should use Mutex<T> instead; RawMutex is for callers that need to manage the lock/unlock pairing themselves.

Implementations

impl RawMutex

pub fn new() -> Result<Self>

Creates a new, unlocked mutex with priority inheritance enabled.

Examples

use osal_rs::os::*;
use osal_rs::utils::OsalRsBool;

let mutex = RawMutex::new().unwrap();
assert_eq!(mutex.lock(), OsalRsBool::True);
assert_eq!(mutex.unlock(), OsalRsBool::True);

Trait Implementations

impl Debug for RawMutex

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

Formats the value using the given formatter.

impl Deref for RawMutex

type Target = pthread_mutex_t

The resulting type after dereferencing.

fn deref(&self) -> &MutexHandle

Dereferences the value.

impl Display for RawMutex

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

Formats the value using the given formatter.

impl Drop for RawMutex

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl RawMutex for RawMutex

fn is_null(&self) -> bool

Returns true if this mutex is never-initialized-or-already-deleted.

Examples

use osal_rs::os::*;

let mut mutex = RawMutex::new().unwrap();
assert!(!mutex.is_null());

mutex.delete();
assert!(mutex.is_null());

fn lock(&self) -> OsalRsBool

Locks the mutex, blocking the calling thread until it becomes available. Returns OsalRsBool::True on success.

Examples

use osal_rs::os::*;
use osal_rs::utils::OsalRsBool;

let mutex = RawMutex::new().unwrap();
assert_eq!(mutex.lock(), OsalRsBool::True);
mutex.unlock();

fn lock_from_isr(&self) -> OsalRsBool

ISR-safe variant of RawMutex::lock. POSIX has no interrupt context of its own, so this never blocks (trylock instead of lock); it returns OsalRsBool::False if the mutex is already held rather than waiting for it.

Examples

use osal_rs::os::*;
use osal_rs::utils::OsalRsBool;

let mutex = RawMutex::new().unwrap();
assert_eq!(mutex.lock_from_isr(), OsalRsBool::True);
mutex.unlock_from_isr();

fn unlock(&self) -> OsalRsBool

Unlocks the mutex. Must be called by the thread that currently holds the lock.

Examples

use osal_rs::os::*;
use osal_rs::utils::OsalRsBool;

let mutex = RawMutex::new().unwrap();
mutex.lock();
assert_eq!(mutex.unlock(), OsalRsBool::True);

fn unlock_from_isr(&self) -> OsalRsBool

ISR-safe variant of RawMutex::unlock; identical on POSIX, since unlocking never blocks.

fn delete(&mut self)

Destroys the underlying pthread mutex and resets it to its “null” state. Safe to call more than once, and called automatically on Drop if not called explicitly.

Examples

use osal_rs::os::*;

let mut mutex = RawMutex::new().unwrap();
mutex.delete();
assert!(mutex.is_null());

impl Send for RawMutex

impl Sync for RawMutex