Blocktree/crates/btserde/src/error.rs

use serde::{de, ser};
use std::{
    fmt::{self, Display},
    io,
};

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
    Message(String),
    Io(std::io::Error),
    Eof,
    UnknownLength,
    SequenceTooLong(usize),
    TooManyVariants(u32),
    TypeConversion,
    NotSupported(&'static str),
    InvalidUtf8Char,
    Format(std::fmt::Error),
    Custom(Box<dyn std::error::Error + Send + Sync>),
}

impl std::error::Error for Error {}

impl Display for Error {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::Message(message) => formatter.write_str(message),
            Error::Io(io_error) => io_error.fmt(formatter),
            Error::Eof => formatter.write_str("unexpected end of input"),
            Error::UnknownLength => formatter.write_str("sequence had an unknown length"),
            Error::SequenceTooLong(length) => formatter.write_fmt(format_args!(
                "sequence was longer than 2**32 - 1: {}",
                length
            )),
            Error::TooManyVariants(length) => formatter.write_fmt(format_args!(
                "too many variants to be serialized, the limit is 2**16: {}",
                length
            )),
            Error::TypeConversion => formatter.write_str("type conversion failed"),
            Error::NotSupported(message) => {
                formatter.write_fmt(format_args!("Operation is not supported: {message}"))
            }
            Error::InvalidUtf8Char => formatter.write_str("Invalid UTF-8 character encountered."),
            Error::Format(fmt_error) => fmt_error.fmt(formatter),
            Error::Custom(err) => err.fmt(formatter),
        }
    }
}

impl Error {
    pub fn custom<E: Into<Box<dyn std::error::Error + Send + Sync>> + 'static>(err: E) -> Error {
        Error::Custom(err.into())
    }
}

impl ser::Error for Error {
    fn custom<T: Display>(message: T) -> Self {
        Error::Message(message.to_string())
    }
}

impl de::Error for Error {
    fn custom<T: Display>(message: T) -> Self {
        Error::Message(message.to_string())
    }
}

impl From<Error> for io::Error {
    fn from(err: Error) -> Self {
        io::Error::new(io::ErrorKind::Other, err)
    }
}

pub trait MapError<T> {
    /// Returns self if no error occurred, otherwise converts the error to a serde_blocktree error.
    fn map_error(self) -> Result<T>;
}

impl<T> MapError<T> for std::io::Result<T> {
    fn map_error(self) -> Result<T> {
        self.map_err(Error::Io)
    }
}