use std::{fmt, sync::Arc};
use crate::{Error, PanicReport, Result, TaskId, context, control::Shared, task::SharedTaskRecord};
pub(crate) struct JoinCell<T> {
pub(crate) outcome: Option<std::result::Result<T, PanicReport>>,
}
pub(crate) trait JoinOutcome<T>: Send + Sync {
fn take(&self) -> Option<std::result::Result<T, PanicReport>>;
}
#[must_use = "observe the result or explicitly drop it; the scope still owns the task"]
pub struct JoinHandle<T> {
shared: Arc<Shared>,
id: TaskId,
cell: Arc<dyn JoinOutcome<T>>,
record: SharedTaskRecord,
taken: bool,
}
impl<T> JoinHandle<T> {
pub(crate) fn new(
shared: Arc<Shared>,
id: TaskId,
cell: Arc<dyn JoinOutcome<T>>,
record: SharedTaskRecord,
) -> Self {
Self {
shared,
id,
cell,
record,
taken: false,
}
}
pub fn task_id(&self) -> TaskId {
self.id
}
pub fn cancellation_token(&self) -> crate::CancellationToken {
self.record.lock().options().cancellation.clone()
}
pub fn cancel(&self) {
self.cancellation_token().cancel();
}
pub fn is_finished(&self) -> bool {
self.record.completion().done()
}
pub fn wait(&mut self) -> Result<()> {
if self.is_finished() {
return Ok(());
}
if context::current().is_some() {
crate::join_wait::wait_for(
&self.record,
crate::SuspensionReason::Join(self.id),
false,
)?;
} else {
let scope = self.record.lock().scope;
self.shared.wait(scope, Some(&self.record))?;
}
Ok(())
}
pub fn join(&mut self) -> Result<T> {
if self.taken {
return Err(Error::ResultAlreadyTaken);
}
self.wait()?;
self.take_result()
}
pub fn take_result(&mut self) -> Result<T> {
if self.taken {
return Err(Error::ResultAlreadyTaken);
}
if !self.is_finished() {
return Err(Error::WouldBlock);
}
self.taken = true;
let (failure, panic) = {
let mut record = self.record.lock();
record.outcome_observed = true;
(record.failure, record.panic.clone())
};
if let Some(reason) = failure {
return Err(Error::TaskAborted {
task: self.id,
reason,
});
}
if let Some(panic) = panic {
let name = self.record.lock().name.to_string();
return Err(Error::task_panicked(self.id, name, panic));
}
let outcome = self.cell.take().ok_or_else(|| {
Error::fault(
crate::error::FaultComponent::Scheduler,
"completed task has no join outcome",
)
})?;
outcome.map_err(|panic| {
let name = self.record.lock().name.to_string();
Error::task_panicked(self.id, name, panic)
})
}
}
impl<T> fmt::Debug for JoinHandle<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
let record = self.record.lock();
formatter
.debug_struct("JoinHandle")
.field("id", &self.id)
.field("name", &record.name)
.field("status", &record.status)
.finish_non_exhaustive()
}
}
#[cfg(test)]
#[path = "join_test.rs"]
mod join_test;
#[cfg(test)]
#[path = "join_commit_test.rs"]
mod join_commit_test;