use std::fmt;
use super::hooks::HookError;
#[derive(Debug)]
pub enum RecycleError<E> {
Message(String),
StaticMessage(&'static str),
Backend(E),
}
impl<E> From<E> for RecycleError<E> {
fn from(e: E) -> Self {
Self::Backend(e)
}
}
impl<E: fmt::Display> fmt::Display for RecycleError<E> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Message(msg) => write!(f, "Error occurred while recycling an object: {}", msg),
Self::StaticMessage(msg) => {
write!(f, "Error occurred while recycling an object: {}", msg)
}
Self::Backend(e) => write!(f, "Error occurred while recycling an object: {}", e),
}
}
}
impl<E: std::error::Error + 'static> std::error::Error for RecycleError<E> {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Message(_) => None,
Self::StaticMessage(_) => None,
Self::Backend(e) => Some(e),
}
}
}
#[derive(Clone, Copy, Debug)]
pub enum TimeoutType {
Wait,
Create,
Recycle,
}
#[derive(Debug)]
pub enum PoolError<E> {
Timeout(TimeoutType),
Backend(E),
Closed,
NoRuntimeSpecified,
PostCreateHook(HookError<E>),
PreRecycleHook(HookError<E>),
PostRecycleHook(HookError<E>),
}
impl<E> From<E> for PoolError<E> {
fn from(e: E) -> Self {
Self::Backend(e)
}
}
impl<E: fmt::Display> fmt::Display for PoolError<E> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Timeout(tt) => match tt {
TimeoutType::Wait => write!(
f,
"Timeout occurred while waiting for a slot to become available"
),
TimeoutType::Create => write!(f, "Timeout occurred while creating a new object"),
TimeoutType::Recycle => write!(f, "Timeout occurred while recycling an object"),
},
Self::Backend(e) => write!(f, "Error occurred while creating a new object: {}", e),
Self::Closed => write!(f, "Pool has been closed"),
Self::NoRuntimeSpecified => write!(f, "No runtime specified"),
Self::PostCreateHook(e) => writeln!(f, "`post_create` hook failed: {}", e),
Self::PreRecycleHook(e) => writeln!(f, "`pre_recycle` hook failed: {}", e),
Self::PostRecycleHook(e) => writeln!(f, "`post_recycle` hook failed: {}", e),
}
}
}
impl<E: std::error::Error + 'static> std::error::Error for PoolError<E> {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Timeout(_) | Self::Closed | Self::NoRuntimeSpecified => None,
Self::Backend(e) => Some(e),
Self::PostCreateHook(e) | Self::PreRecycleHook(e) | Self::PostRecycleHook(e) => Some(e),
}
}
}