use crate::connection::ConnectionLimit;
use crate::transport::TransportError;
use std::{io, fmt};
#[derive(Debug)]
pub enum ConnectionError<THandlerErr> {
IO(io::Error),
Handler(THandlerErr),
}
impl<THandlerErr> fmt::Display
for ConnectionError<THandlerErr>
where
THandlerErr: fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ConnectionError::IO(err) =>
write!(f, "Connection error: I/O error: {}", err),
ConnectionError::Handler(err) =>
write!(f, "Connection error: Handler error: {}", err),
}
}
}
impl<THandlerErr> std::error::Error
for ConnectionError<THandlerErr>
where
THandlerErr: std::error::Error + 'static,
{
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
ConnectionError::IO(err) => Some(err),
ConnectionError::Handler(err) => Some(err),
}
}
}
#[derive(Debug)]
pub enum PendingConnectionError<TTransErr> {
Transport(TransportError<TTransErr>),
InvalidPeerId,
ConnectionLimit(ConnectionLimit),
IO(io::Error),
}
impl<TTransErr> fmt::Display
for PendingConnectionError<TTransErr>
where
TTransErr: fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
PendingConnectionError::IO(err) =>
write!(f, "Pending connection: I/O error: {}", err),
PendingConnectionError::Transport(err) =>
write!(f, "Pending connection: Transport error: {}", err),
PendingConnectionError::InvalidPeerId =>
write!(f, "Pending connection: Invalid peer ID."),
PendingConnectionError::ConnectionLimit(l) =>
write!(f, "Connection error: Connection limit: {}.", l),
}
}
}
impl<TTransErr> std::error::Error
for PendingConnectionError<TTransErr>
where
TTransErr: std::error::Error + 'static
{
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
PendingConnectionError::IO(err) => Some(err),
PendingConnectionError::Transport(err) => Some(err),
PendingConnectionError::InvalidPeerId => None,
PendingConnectionError::ConnectionLimit(..) => None,
}
}
}