use core::cell::UnsafeCell;
use core::ops::Deref;
use core::ops::DerefMut;
use embassy_sync::blocking_mutex::raw::RawMutex;
use embassy_sync::semaphore::FairSemaphore;
use embassy_sync::semaphore::Semaphore;
use embassy_sync::semaphore::SemaphoreReleaser;
pub use embassy_sync::semaphore::WaitQueueFull;
const MAX_WAITERS: usize = 4;
type Permits<M> = FairSemaphore<M, MAX_WAITERS>;
pub struct FairMutex<M: RawMutex, T> {
permits: Permits<M>,
value: UnsafeCell<T>,
}
unsafe impl<M: RawMutex + Send, T: Send> Send for FairMutex<M, T> {}
unsafe impl<M: RawMutex + Sync, T: Send> Sync for FairMutex<M, T> {}
impl<M: RawMutex, T> FairMutex<M, T> {
pub const fn new(value: T) -> Self {
Self {
permits: FairSemaphore::new(1),
value: UnsafeCell::new(value),
}
}
pub async fn lock(&self) -> Result<FairMutexGuard<'_, M, T>, WaitQueueFull> {
let permit = self.permits.acquire(1).await?;
Ok(FairMutexGuard {
mutex: self,
_permit: permit,
})
}
}
#[must_use = "if unused the FairMutex will immediately unlock"]
pub struct FairMutexGuard<'a, M: RawMutex, T> {
mutex: &'a FairMutex<M, T>,
_permit: SemaphoreReleaser<'a, Permits<M>>,
}
impl<M: RawMutex, T> Deref for FairMutexGuard<'_, M, T> {
type Target = T;
fn deref(&self) -> &T {
unsafe { &*self.mutex.value.get() }
}
}
impl<M: RawMutex, T> DerefMut for FairMutexGuard<'_, M, T> {
fn deref_mut(&mut self) -> &mut T {
unsafe { &mut *self.mutex.value.get() }
}
}