rustensor 0.1.0

Small Rust-native checkpoint format for model metadata and tensor weights.
Documentation
//! Error types used by rustensor.
//!
//! This module defines controlled errors for format validation, checkpoint
//! validation, I/O, serialization and integrity verification.
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)
    }
}