use std::io::Error as IoError;
use std::sync::mpsc::RecvError;
use futures::sync::mpsc::SendError;
use futures::sync::oneshot::Canceled;
use native_tls::Error as TlsError;
#[cfg(feature = "json")]
use serde_json::Error as JsonError;
#[cfg(feature = "yaml")]
use serde_yaml::Error as YamlError;
use tokio_timer::TimerError;
#[cfg(feature = "toml")]
use toml::de::Error as TomlReadError;
#[cfg(feature = "toml")]
use toml::ser::Error as TomlWriteError;
use proto::Message;
pub type Result<T> = ::std::result::Result<T, IrcError>;
#[derive(Debug, Fail)]
pub enum IrcError {
#[fail(display = "an io error occurred")]
Io(#[cause] IoError),
#[fail(display = "a TLS error occurred")]
Tls(#[cause] TlsError),
#[fail(display = "a sync channel closed")]
SyncChannelClosed(#[cause] RecvError),
#[fail(display = "an async channel closed")]
AsyncChannelClosed(#[cause] SendError<Message>),
#[fail(display = "a oneshot channel closed")]
OneShotCanceled(#[cause] Canceled),
#[fail(display = "timer failed")]
Timer(#[cause] TimerError),
#[fail(display = "invalid config: {}", path)]
InvalidConfig {
path: String,
#[cause]
cause: ConfigError,
},
#[fail(display = "invalid message: {}", string)]
InvalidMessage {
string: String,
#[cause]
cause: MessageParseError,
},
#[fail(display = "mutex for a logged transport was poisoned")]
PoisonedLog,
#[fail(display = "connection reset: no ping response")]
PingTimeout,
#[fail(display = "unknown codec: {}", codec)]
UnknownCodec {
codec: String,
},
#[fail(display = "codec {} failed: {}", codec, data)]
CodecFailed {
codec: &'static str,
data: String,
},
}
#[derive(Debug, Fail)]
pub enum MessageParseError {
#[fail(display = "empty message")]
EmptyMessage,
#[fail(display = "invalid command")]
InvalidCommand,
#[fail(display = "invalid mode string: {}", string)]
InvalidModeString {
string: String,
#[cause]
cause: ModeParseError,
},
#[fail(display = "invalid {} subcommand: {}", cmd, sub)]
InvalidSubcommand {
cmd: &'static str,
sub: String,
}
}
#[derive(Debug, Fail)]
pub enum ModeParseError {
#[fail(display = "invalid mode modifier: {}", modifier)]
InvalidModeModifier {
modifier: char,
},
#[fail(display = "missing mode modifier")]
MissingModeModifier,
}
#[derive(Debug, Fail)]
pub enum ConfigError {
#[cfg(feature = "toml")]
#[fail(display = "invalid toml")]
InvalidToml(#[cause] TomlError),
#[cfg(feature = "json")]
#[fail(display = "invalid json")]
InvalidJson(#[cause] JsonError),
#[cfg(feature = "yaml")]
#[fail(display = "invalid yaml")]
InvalidYaml(#[cause] YamlError),
#[fail(display = "config format disabled: {}", format)]
ConfigFormatDisabled {
format: &'static str,
},
#[fail(display = "config format unknown: {}", format)]
UnknownConfigFormat {
format: String,
},
#[fail(display = "missing format extension")]
MissingExtension,
#[fail(display = "nickname not specified")]
NicknameNotSpecified,
#[fail(display = "server not specified")]
ServerNotSpecified,
}
#[cfg(feature = "toml")]
#[derive(Debug, Fail)]
pub enum TomlError {
#[fail(display = "deserialization failed")]
Read(#[cause] TomlReadError),
#[fail(display = "serialization failed")]
Write(#[cause] TomlWriteError),
}
impl From<IoError> for IrcError {
fn from(e: IoError) -> IrcError {
IrcError::Io(e)
}
}
impl From<TlsError> for IrcError {
fn from(e: TlsError) -> IrcError {
IrcError::Tls(e)
}
}
impl From<RecvError> for IrcError {
fn from(e: RecvError) -> IrcError {
IrcError::SyncChannelClosed(e)
}
}
impl From<SendError<Message>> for IrcError {
fn from(e: SendError<Message>) -> IrcError {
IrcError::AsyncChannelClosed(e)
}
}
impl From<Canceled> for IrcError {
fn from(e: Canceled) -> IrcError {
IrcError::OneShotCanceled(e)
}
}
impl From<TimerError> for IrcError {
fn from(e: TimerError) -> IrcError {
IrcError::Timer(e)
}
}