use crate::{ChannelId, DeviceId};
use std::error::Error;
use std::fmt;
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ConfigError {
EmptyId,
DuplicateDevice(DeviceId),
DuplicateChannel(ChannelId),
UnknownDevice(DeviceId),
UnknownChannel(ChannelId),
SelfConnectedChannel(ChannelId),
ZeroBitRate(ChannelId),
InvalidDegradedRate(ChannelId),
InvalidMobility(DeviceId),
InvalidReceiverInterference(DeviceId),
InvalidDistanceModel(ChannelId),
InvalidRadio(ChannelId),
InvalidSimulatorOptions(String),
ChannelNotConnected {
device: DeviceId,
channel: ChannelId,
},
}
impl fmt::Display for ConfigError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::EmptyId => write!(formatter, "device and channel identifiers cannot be empty"),
Self::DuplicateDevice(id) => write!(formatter, "duplicate device identifier `{id}`"),
Self::DuplicateChannel(id) => write!(formatter, "duplicate channel identifier `{id}`"),
Self::UnknownDevice(id) => write!(formatter, "unknown device `{id}`"),
Self::UnknownChannel(id) => write!(formatter, "unknown channel `{id}`"),
Self::SelfConnectedChannel(id) => {
write!(
formatter,
"channel `{id}` must connect two different devices"
)
}
Self::ZeroBitRate(id) => write!(formatter, "channel `{id}` has a zero bit rate"),
Self::InvalidDegradedRate(id) => {
write!(formatter, "channel `{id}` has an invalid degraded bit rate")
}
Self::InvalidMobility(id) => write!(formatter, "device `{id}` has invalid mobility"),
Self::InvalidReceiverInterference(id) => {
write!(formatter, "device `{id}` has invalid receiver interference")
}
Self::InvalidDistanceModel(id) => {
write!(formatter, "channel `{id}` has an invalid distance model")
}
Self::InvalidRadio(id) => {
write!(formatter, "channel `{id}` has an invalid radio model")
}
Self::InvalidSimulatorOptions(id) => write!(
formatter,
"channel `{id}` has invalid packet-engine options"
),
Self::ChannelNotConnected { device, channel } => write!(
formatter,
"channel `{channel}` is not connected to device `{device}`"
),
}
}
}
impl Error for ConfigError {}
#[derive(Debug)]
pub enum ConfigLoadError {
Parse {
format: &'static str,
message: String,
},
Invalid(ConfigError),
}
impl fmt::Display for ConfigLoadError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Parse { format, message } => {
write!(
formatter,
"could not parse {format} network configuration: {message}"
)
}
Self::Invalid(error) => write!(formatter, "invalid network configuration: {error}"),
}
}
}
impl Error for ConfigLoadError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Parse { .. } => None,
Self::Invalid(error) => Some(error),
}
}
}
impl From<ConfigError> for ConfigLoadError {
fn from(value: ConfigError) -> Self {
Self::Invalid(value)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum SimulationError {
InvalidConfig(ConfigError),
UnknownDevice(DeviceId),
UnknownChannel(ChannelId),
NotASource(DeviceId),
TimeInPast,
InvalidChannelState(ChannelId),
InvalidReceiverInterference(DeviceId),
TimeOverflow,
PacketIdOverflow,
}
impl fmt::Display for SimulationError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidConfig(error) => error.fmt(formatter),
Self::UnknownDevice(id) => write!(formatter, "unknown device `{id}`"),
Self::UnknownChannel(id) => write!(formatter, "unknown channel `{id}`"),
Self::NotASource(id) => write!(formatter, "device `{id}` is not a source"),
Self::TimeInPast => write!(formatter, "cannot schedule an event in the past"),
Self::InvalidChannelState(id) => {
write!(formatter, "invalid state for channel `{id}`")
}
Self::InvalidReceiverInterference(id) => {
write!(formatter, "invalid receiver interference for device `{id}`")
}
Self::TimeOverflow => write!(formatter, "simulated time overflowed"),
Self::PacketIdOverflow => write!(formatter, "packet identifier space exhausted"),
}
}
}
impl Error for SimulationError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::InvalidConfig(error) => Some(error),
_ => None,
}
}
}
impl From<ConfigError> for SimulationError {
fn from(value: ConfigError) -> Self {
Self::InvalidConfig(value)
}
}