use std::error::Error;
use std::{cell, io, result, str};
#[cfg(feature = "arrow")]
use arrow_schema::ArrowError;
#[derive(Debug)]
pub enum ParquetError {
General(String),
NYI(String),
EOF(String),
#[cfg(feature = "arrow")]
ArrowError(String),
IndexOutOfBound(usize, usize),
External(Box<dyn Error + Send + Sync>),
}
impl std::fmt::Display for ParquetError {
fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
match &self {
ParquetError::General(message) => {
write!(fmt, "Parquet error: {message}")
}
ParquetError::NYI(message) => write!(fmt, "NYI: {message}"),
ParquetError::EOF(message) => write!(fmt, "EOF: {message}"),
#[cfg(feature = "arrow")]
ParquetError::ArrowError(message) => write!(fmt, "Arrow: {message}"),
ParquetError::IndexOutOfBound(index, ref bound) => {
write!(fmt, "Index {index} out of bound: {bound}")
}
ParquetError::External(e) => write!(fmt, "External: {e}"),
}
}
}
impl Error for ParquetError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
ParquetError::External(e) => Some(e.as_ref()),
_ => None,
}
}
}
impl From<io::Error> for ParquetError {
fn from(e: io::Error) -> ParquetError {
ParquetError::External(Box::new(e))
}
}
#[cfg(any(feature = "snap", test))]
impl From<snap::Error> for ParquetError {
fn from(e: snap::Error) -> ParquetError {
ParquetError::External(Box::new(e))
}
}
impl From<thrift::Error> for ParquetError {
fn from(e: thrift::Error) -> ParquetError {
ParquetError::External(Box::new(e))
}
}
impl From<cell::BorrowMutError> for ParquetError {
fn from(e: cell::BorrowMutError) -> ParquetError {
ParquetError::External(Box::new(e))
}
}
impl From<str::Utf8Error> for ParquetError {
fn from(e: str::Utf8Error) -> ParquetError {
ParquetError::External(Box::new(e))
}
}
#[cfg(feature = "arrow")]
impl From<ArrowError> for ParquetError {
fn from(e: ArrowError) -> ParquetError {
ParquetError::External(Box::new(e))
}
}
pub type Result<T, E = ParquetError> = result::Result<T, E>;
impl From<ParquetError> for io::Error {
fn from(e: ParquetError) -> Self {
io::Error::new(io::ErrorKind::Other, e)
}
}
macro_rules! general_err {
($fmt:expr) => (ParquetError::General($fmt.to_owned()));
($fmt:expr, $($args:expr),*) => (ParquetError::General(format!($fmt, $($args),*)));
($e:expr, $fmt:expr) => (ParquetError::General($fmt.to_owned(), $e));
($e:ident, $fmt:expr, $($args:tt),*) => (
ParquetError::General(&format!($fmt, $($args),*), $e));
}
macro_rules! nyi_err {
($fmt:expr) => (ParquetError::NYI($fmt.to_owned()));
($fmt:expr, $($args:expr),*) => (ParquetError::NYI(format!($fmt, $($args),*)));
}
macro_rules! eof_err {
($fmt:expr) => (ParquetError::EOF($fmt.to_owned()));
($fmt:expr, $($args:expr),*) => (ParquetError::EOF(format!($fmt, $($args),*)));
}
#[cfg(feature = "arrow")]
macro_rules! arrow_err {
($fmt:expr) => (ParquetError::ArrowError($fmt.to_owned()));
($fmt:expr, $($args:expr),*) => (ParquetError::ArrowError(format!($fmt, $($args),*)));
($e:expr, $fmt:expr) => (ParquetError::ArrowError($fmt.to_owned(), $e));
($e:ident, $fmt:expr, $($args:tt),*) => (
ParquetError::ArrowError(&format!($fmt, $($args),*), $e));
}
#[cfg(feature = "arrow")]
impl From<ParquetError> for ArrowError {
fn from(p: ParquetError) -> Self {
Self::ParquetError(format!("{p}"))
}
}