use std::{
cell::Cell,
convert::Infallible,
fmt, io,
marker::PhantomData,
sync::{Arc, Condvar, Mutex, MutexGuard},
};
use crate::{Span, WakeHandle, WakeSource};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WaitOutcome {
Notified,
Idle,
}
pub trait Waiter<D> {
type Error;
fn wait(&mut self, duty: &mut D, maximum: Span) -> Result<WaitOutcome, Self::Error>;
}
impl<D, F, E> Waiter<D> for F
where
F: FnMut(&mut D, Span) -> Result<WaitOutcome, E>,
{
type Error = E;
fn wait(&mut self, duty: &mut D, maximum: Span) -> Result<WaitOutcome, Self::Error> {
self(duty, maximum)
}
}
pub struct ThreadParker {
shared: Arc<ThreadParkState>,
_single_owner: PhantomData<Cell<()>>,
}
#[derive(Clone)]
pub struct ThreadNotifier {
shared: Arc<ThreadParkState>,
}
pub fn thread_parker() -> (ThreadParker, ThreadNotifier) {
let shared = Arc::new(ThreadParkState {
notified: Mutex::new(false),
changed: Condvar::new(),
});
(
ThreadParker {
shared: Arc::clone(&shared),
_single_owner: PhantomData,
},
ThreadNotifier { shared },
)
}
impl ThreadNotifier {
pub fn wake_handle(&self) -> WakeHandle {
WakeHandle::new(self.clone())
}
pub fn notify(&self) {
let mut notified = self.shared.lock();
*notified = true;
self.shared.changed.notify_one();
}
}
impl WakeSource for ThreadNotifier {
fn wake(&self) -> io::Result<()> {
self.notify();
Ok(())
}
}
impl<D> Waiter<D> for ThreadParker {
type Error = Infallible;
fn wait(&mut self, _duty: &mut D, maximum: Span) -> Result<WaitOutcome, Self::Error> {
let mut notified = self.shared.lock();
if *notified {
*notified = false;
return Ok(WaitOutcome::Notified);
}
if maximum.as_nanos() == 0 {
return Ok(WaitOutcome::Idle);
}
let waited =
self.shared
.changed
.wait_timeout_while(notified, maximum.as_duration(), |pending| !*pending);
let (mut notified, _timeout) = waited.unwrap_or_else(std::sync::PoisonError::into_inner);
if *notified {
*notified = false;
Ok(WaitOutcome::Notified)
} else {
Ok(WaitOutcome::Idle)
}
}
}
impl fmt::Debug for ThreadParker {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ThreadParker")
.field("notified", &*self.shared.lock())
.finish_non_exhaustive()
}
}
impl fmt::Debug for ThreadNotifier {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ThreadNotifier")
.field("notified", &*self.shared.lock())
.finish_non_exhaustive()
}
}
struct ThreadParkState {
notified: Mutex<bool>,
changed: Condvar,
}
impl ThreadParkState {
fn lock(&self) -> MutexGuard<'_, bool> {
self.notified
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
}