use std::{error, fmt};
#[allow(clippy::enum_variant_names)]
#[derive(Debug, PartialEq)]
pub enum PeerManagerError {
StartUpError(String),
SendMessageError(String),
}
impl error::Error for PeerManagerError {}
impl fmt::Display for PeerManagerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
PeerManagerError::StartUpError(msg) => write!(f, "{}", msg),
PeerManagerError::SendMessageError(msg) => write!(f, "{}", msg),
}
}
}
#[allow(clippy::enum_variant_names)]
#[derive(Debug, PartialEq)]
pub enum PeerRefAddError {
InternalError(String),
ReceiveError(String),
AddError(String),
}
impl error::Error for PeerRefAddError {}
impl fmt::Display for PeerRefAddError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
PeerRefAddError::InternalError(msg) => write!(f, "Received internal error: {}", msg),
PeerRefAddError::ReceiveError(msg) => {
write!(f, "Unable to receive response from PeerManager: {}", msg)
}
PeerRefAddError::AddError(msg) => write!(f, "Unable to add peer: {}", msg),
}
}
}
#[allow(clippy::enum_variant_names)]
#[derive(Debug, PartialEq)]
pub enum PeerUnknownAddError {
InternalError(String),
ReceiveError(String),
AddError(String),
}
impl error::Error for PeerUnknownAddError {}
impl fmt::Display for PeerUnknownAddError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
PeerUnknownAddError::InternalError(msg) => {
write!(f, "Received internal error: {}", msg)
}
PeerUnknownAddError::ReceiveError(msg) => {
write!(f, "Unable to receive response from PeerManager: {}", msg)
}
PeerUnknownAddError::AddError(msg) => {
write!(f, "Unable to add unidentified peer: {}", msg)
}
}
}
}
#[derive(Debug, PartialEq)]
pub enum PeerRefRemoveError {
Internal(String),
Receive(String),
Remove(String),
}
impl error::Error for PeerRefRemoveError {}
impl fmt::Display for PeerRefRemoveError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
PeerRefRemoveError::Internal(msg) => write!(f, "Received internal error: {}", msg),
PeerRefRemoveError::Receive(msg) => {
write!(f, "Unable to receive response from PeerManager: {}", msg)
}
PeerRefRemoveError::Remove(msg) => write!(f, "Unable to remove peer: {}", msg),
}
}
}
#[derive(Debug, PartialEq)]
pub enum PeerListError {
Internal(String),
Receive(String),
List(String),
}
impl error::Error for PeerListError {}
impl fmt::Display for PeerListError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
PeerListError::Internal(msg) => write!(f, "Received internal error: {}", msg),
PeerListError::Receive(msg) => {
write!(f, "Unable to receive response from PeerManager: {}", msg)
}
PeerListError::List(msg) => write!(f, "Unable to list peers: {}", msg),
}
}
}
#[allow(clippy::enum_variant_names)]
#[derive(Debug, PartialEq)]
pub enum PeerConnectionIdError {
InternalError(String),
ReceiveError(String),
ListError(String),
}
impl error::Error for PeerConnectionIdError {}
impl fmt::Display for PeerConnectionIdError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
PeerConnectionIdError::InternalError(msg) => {
write!(f, "Received internal error: {}", msg)
}
PeerConnectionIdError::ReceiveError(msg) => {
write!(f, "Unable to receive response from PeerManager: {}", msg)
}
PeerConnectionIdError::ListError(msg) => {
write!(f, "Unable to get connection id map: {}", msg)
}
}
}
}
#[derive(Debug)]
pub struct PeerUpdateError(pub String);
impl error::Error for PeerUpdateError {}
impl fmt::Display for PeerUpdateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Unable to update peer, {}", self.0)
}
}
#[derive(Debug)]
pub struct PeerLookupError(pub String);
impl error::Error for PeerLookupError {}
impl fmt::Display for PeerLookupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(&self.0)
}
}