use std::{fmt, io, num::NonZeroUsize};
use super::{ReactorGroupMember, ReactorId};
#[derive(Debug)]
pub enum ReactorGroupSpawnFailure {
Empty,
Capacity {
limit: NonZeroUsize,
actual: usize,
},
Identity {
expected: ReactorId,
actual: ReactorId,
},
ReactorThread {
reactor: ReactorId,
source: io::Error,
},
SupervisorThread {
source: io::Error,
},
}
pub struct ReactorGroupSpawnError<D, C, W, T> {
failure: ReactorGroupSpawnFailure,
members: Vec<ReactorGroupMember<D, C, W, T>>,
}
impl<D, C, W, T> ReactorGroupSpawnError<D, C, W, T> {
pub(super) const fn new(
failure: ReactorGroupSpawnFailure,
members: Vec<ReactorGroupMember<D, C, W, T>>,
) -> Self {
Self { failure, members }
}
pub const fn failure(&self) -> &ReactorGroupSpawnFailure {
&self.failure
}
pub fn into_members(self) -> Vec<ReactorGroupMember<D, C, W, T>> {
self.members
}
pub fn into_parts(
self,
) -> (
ReactorGroupSpawnFailure,
Vec<ReactorGroupMember<D, C, W, T>>,
) {
(self.failure, self.members)
}
}
impl fmt::Display for ReactorGroupSpawnFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Empty => formatter.write_str("reactor group topology is empty"),
Self::Capacity { limit, actual } => write!(
formatter,
"reactor group has {actual} members but limit is {limit}"
),
Self::Identity { expected, actual } => write!(
formatter,
"reactor group member at position {} declared identity {}",
expected.get(),
actual.get()
),
Self::ReactorThread { reactor, source } => write!(
formatter,
"reactor {} thread creation failed: {source}",
reactor.get()
),
Self::SupervisorThread { source } => {
write!(
formatter,
"reactor group supervisor creation failed: {source}"
)
}
}
}
}
impl<D, C, W, T> fmt::Display for ReactorGroupSpawnError<D, C, W, T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.failure.fmt(formatter)
}
}
impl<D, C, W, T> fmt::Debug for ReactorGroupSpawnError<D, C, W, T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ReactorGroupSpawnError")
.field("failure", &self.failure)
.field("member_count", &self.members.len())
.finish_non_exhaustive()
}
}
impl<D, C, W, T> std::error::Error for ReactorGroupSpawnError<D, C, W, T> {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.failure {
ReactorGroupSpawnFailure::ReactorThread { source, .. }
| ReactorGroupSpawnFailure::SupervisorThread { source } => Some(source),
ReactorGroupSpawnFailure::Empty
| ReactorGroupSpawnFailure::Capacity { .. }
| ReactorGroupSpawnFailure::Identity { .. } => None,
}
}
}