use std::any::Any;
use crate::{Clock, Duty, ReactorExit, Waiter};
use super::ReactorId;
pub enum ReactorGroupMemberExit<D, C, W>
where
D: Duty,
C: Clock,
W: Waiter<D>,
{
Exited(ReactorExit<D, C, W>),
Panicked(Box<dyn Any + Send + 'static>),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ReactorGroupOutcome {
Stopped,
Terminated,
Failed(ReactorId),
Panicked(ReactorId),
}
pub struct ReactorGroupExit<D, C, W>
where
D: Duty,
C: Clock,
W: Waiter<D>,
{
outcome: ReactorGroupOutcome,
members: Box<[ReactorGroupMemberExit<D, C, W>]>,
}
pub(super) struct Supervised<D, C, W>
where
D: Duty,
C: Clock,
W: Waiter<D>,
{
pub(super) outcome: ReactorGroupOutcome,
pub(super) members: Box<[ReactorGroupMemberExit<D, C, W>]>,
}
impl<D, C, W> ReactorGroupExit<D, C, W>
where
D: Duty,
C: Clock,
W: Waiter<D>,
{
pub(super) fn new(supervised: Supervised<D, C, W>) -> Self {
Self {
outcome: supervised.outcome,
members: supervised.members,
}
}
pub const fn outcome(&self) -> ReactorGroupOutcome {
self.outcome
}
pub const fn len(&self) -> usize {
self.members.len()
}
pub const fn is_empty(&self) -> bool {
self.members.is_empty()
}
pub fn member(&self, reactor: ReactorId) -> Option<&ReactorGroupMemberExit<D, C, W>> {
reactor
.position()
.and_then(|position| self.members.get(position))
}
pub fn members(&self) -> impl Iterator<Item = (ReactorId, &ReactorGroupMemberExit<D, C, W>)> {
self.members
.iter()
.enumerate()
.map(|(index, exit)| (ReactorId::from_position(index), exit))
}
pub fn into_members(self) -> Box<[ReactorGroupMemberExit<D, C, W>]> {
self.members
}
}
impl<D, C, W> ReactorGroupMemberExit<D, C, W>
where
D: Duty,
C: Clock,
W: Waiter<D>,
{
pub fn into_result(self) -> std::thread::Result<ReactorExit<D, C, W>> {
match self {
Self::Exited(exit) => Ok(exit),
Self::Panicked(payload) => Err(payload),
}
}
}
impl<D, C, W> core::fmt::Debug for ReactorGroupMemberExit<D, C, W>
where
D: Duty,
C: Clock,
W: Waiter<D>,
ReactorExit<D, C, W>: core::fmt::Debug,
{
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Exited(exit) => formatter.debug_tuple("Exited").field(exit).finish(),
Self::Panicked(_) => formatter.debug_tuple("Panicked").finish_non_exhaustive(),
}
}
}
impl<D, C, W> core::fmt::Debug for ReactorGroupExit<D, C, W>
where
D: Duty,
D::Error: core::fmt::Debug,
C: Clock,
C::Error: core::fmt::Debug,
W: Waiter<D>,
W::Error: core::fmt::Debug,
D: core::fmt::Debug,
C: core::fmt::Debug,
W: core::fmt::Debug,
{
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter
.debug_struct("ReactorGroupExit")
.field("outcome", &self.outcome)
.field("members", &self.members)
.finish()
}
}