Blocktree/crates/btserde/src/error.rs

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

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)
}

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),
        }
    }
}

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())
    }
}

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)
    }
}