use std::fmt;
pub type Result<T> = std::result::Result<T, RustensorError>;
#[derive(Debug)]
pub enum RustensorError {
IoError(std::io::Error),
InvalidMagic,
UnsupportedVersion { found: u16, supported: u16 },
InvalidHeader,
InvalidFlags { found: u16 },
InvalidPayloadLength { expected: u64, found: u64 },
PayloadTooLarge { found: u64, max: u64 },
ChecksumMismatch,
DecodeError(String),
EncodeError(String),
InvalidMetadata { field: &'static str },
InvalidLayerName,
DuplicateLayerName { name: String },
TooManyLayers { found: usize, max: usize },
InvalidTensorShape { reason: String },
InvalidTensorDataLength { expected: usize, found: usize },
InvalidTensorData { reason: String },
}
impl fmt::Display for RustensorError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
RustensorError::IoError(error) => write!(f, "io error: {error}"),
RustensorError::InvalidMagic => write!(f, "invalid RTEN magic bytes"),
RustensorError::UnsupportedVersion { found, supported } => {
write!(
f,
"unsupported RTEN version: found {found}, supported {supported}"
)
}
RustensorError::InvalidHeader => write!(f, "invalid RTEN header"),
RustensorError::InvalidFlags { found } => {
write!(f, "invalid RTEN flags: {found}")
}
RustensorError::InvalidPayloadLength { expected, found } => {
write!(
f,
"invalid payload length: expected {expected}, found {found}"
)
}
RustensorError::PayloadTooLarge { found, max } => {
write!(
f,
"payload too large: {found} bytes, max allowed is {max} bytes"
)
}
RustensorError::ChecksumMismatch => write!(f, "RTEN checksum mismatch"),
RustensorError::DecodeError(message) => write!(f, "decode error: {message}"),
RustensorError::EncodeError(message) => write!(f, "encode error: {message}"),
RustensorError::InvalidMetadata { field } => {
write!(f, "invalid metadata field: {field}")
}
RustensorError::InvalidLayerName => write!(f, "invalid layer name"),
RustensorError::DuplicateLayerName { name } => {
write!(f, "duplicate layer name: {name}")
}
RustensorError::TooManyLayers { found, max } => {
write!(f, "too many layers: {found}, max allowed is {max}")
}
RustensorError::InvalidTensorShape { reason } => {
write!(f, "invalid tensor shape: {reason}")
}
RustensorError::InvalidTensorDataLength { expected, found } => {
write!(
f,
"invalid tensor data length: expected {expected}, found {found}"
)
}
RustensorError::InvalidTensorData { reason } => {
write!(f, "invalid tensor data: {reason}")
}
}
}
}
impl std::error::Error for RustensorError {}
impl From<std::io::Error> for RustensorError {
fn from(error: std::io::Error) -> Self {
RustensorError::IoError(error)
}
}