// SPDX-License-Identifier: AGPL-3.0-or-later use serde::{de, ser}; use std::{ fmt::{self, Display}, io, }; pub type Result = std::result::Result; #[derive(Debug)] pub enum Error { Message(String), Io(std::io::Error), Eof, UnknownLength, SequenceTooLong(usize), TooManyVariants(u32), TypeConversion, NotSupported(&'static str), InvalidUtf8, Format(std::fmt::Error), Custom(Box), } 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::InvalidUtf8 => 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> + 'static>(err: E) -> Error { Error::Custom(err.into()) } } impl ser::Error for Error { fn custom(message: T) -> Self { Error::Message(message.to_string()) } } impl de::Error for Error { fn custom(message: T) -> Self { Error::Message(message.to_string()) } } impl From for io::Error { fn from(err: Error) -> Self { io::Error::new(io::ErrorKind::Other, err) } } pub trait MapError { /// Returns self if no error occurred, otherwise converts the error to a serde_blocktree error. fn map_error(self) -> Result; } impl MapError for std::io::Result { fn map_error(self) -> Result { self.map_err(Error::Io) } }