use std::fmt::Display;
use std::io;
use flodl::tensor::TensorError;
use crate::graph::topology::{Connection, Port};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TopologyError {
NonContiguousNodeIds,
EmptyTopology,
InvalidOptions(String),
UnknownNode(usize),
BackwardConnection(Connection),
PortOutOfBounds { port: Port, num_ports: usize },
DoubleUsedOutput(Port),
MultiWiredInputPort(Port),
}
impl Display for TopologyError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
TopologyError::NonContiguousNodeIds => {
write!(
f,
"node ids must be contiguous 0..n (they double as array indices)"
)
}
TopologyError::EmptyTopology => write!(f, "graph has no nodes"),
TopologyError::InvalidOptions(msg) => write!(f, "invalid options: {msg}"),
TopologyError::UnknownNode(id) => write!(f, "connection references unknown node {id}"),
TopologyError::BackwardConnection(c) => {
write!(
f,
"connection is not forward-only (from.node must be < to.node): {c}"
)
}
TopologyError::PortOutOfBounds { port, num_ports } => write!(
f,
"port n{}[{}] is out of bounds (node has {num_ports} ports)",
port.node, port.index
),
TopologyError::DoubleUsedOutput(p) => {
write!(f, "output port n{}_o{} is used twice", p.node, p.index)
}
TopologyError::MultiWiredInputPort(p) => write!(
f,
"input port n{}_i{} carries more than one wire (one wire per port: \
give the node another input port instead)",
p.node, p.index
),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NetworkError {
InvalidTopology(TopologyError),
Build(String),
Json(String),
}
impl Display for NetworkError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
NetworkError::InvalidTopology(e) => write!(f, "invalid graph: {e}"),
NetworkError::Build(msg) => write!(f, "cannot build network: {msg}"),
NetworkError::Json(msg) => write!(f, "network: JSON: {msg}"),
}
}
}
#[derive(Debug)]
pub enum EngineError {
InvalidOptions(String),
DataMismatch(String),
Io { path: String, source: io::Error },
Json(String),
Rayon(String),
}
impl Display for EngineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
EngineError::InvalidOptions(msg) => write!(f, "engine: invalid options: {msg}"),
EngineError::DataMismatch(msg) => write!(f, "engine: {msg}"),
EngineError::Io { path, source } => {
write!(f, "engine: cannot access {path}: {source}")
}
EngineError::Json(msg) => write!(f, "engine: JSON: {msg}"),
EngineError::Rayon(msg) => write!(f, "engine: parallel evaluation pool: {msg}"),
}
}
}
#[derive(Debug)]
pub enum DataError {
Io { path: String, source: io::Error },
BadMagic { path: String },
Truncated(String),
SizeMismatch {
path: String,
expected: usize,
found: usize,
},
RowCountMismatch { inputs: usize, targets: usize },
UnsupportedDtype(String),
UnknownDtypeTag(u8),
Json(String),
Csv(String),
}
impl Display for DataError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
DataError::Io { path, source } => {
write!(f, "gras data: cannot access {path}: {source}")
}
DataError::BadMagic { path } => {
write!(f, "gras data: {path} is not a gras tensor file (bad magic)")
}
DataError::Truncated(msg) => write!(f, "gras data: truncated tensor file: {msg}"),
DataError::SizeMismatch {
path,
expected,
found,
} => write!(
f,
"gras data: {path} has {found} data bytes, expected {expected}"
),
DataError::RowCountMismatch { inputs, targets } => write!(
f,
"gras data: inputs and targets disagree on row count: {inputs} vs {targets}"
),
DataError::UnsupportedDtype(msg) => {
write!(f, "gras data: unsupported dtype: {msg}")
}
DataError::UnknownDtypeTag(tag) => {
write!(f, "gras data: unknown dtype tag {tag} in tensor file")
}
DataError::Json(msg) => write!(f, "gras data: JSON: {msg}"),
DataError::Csv(msg) => write!(f, "gras data: CSV: {msg}"),
}
}
}
impl From<DataError> for TensorError {
fn from(e: DataError) -> Self {
TensorError::new(&e.to_string())
}
}
impl From<NetworkError> for TensorError {
fn from(e: NetworkError) -> Self {
TensorError::new(&e.to_string())
}
}
impl From<EngineError> for TensorError {
fn from(e: EngineError) -> Self {
TensorError::new(&e.to_string())
}
}