anyxml 0.15.0

//! General error types.

use std::sync::Arc;

use crate::{
    encoding::{DecodeError, EncodeError},
    parse::ParseError,
    relaxng::{RncParseError, RngParseError, RngValidError},
    tree::XMLTreeError,
    uri::ParseRIError,
    xinclude::XIncludeError,
    xpath::{XPathCompileError, XPathError},
    xpointer::XPointerParseError,
};

/// Error level.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum XMLErrorLevel {
    /// Fatal error
    FatalError,
    /// Error
    Error,
    /// Warning
    Warning,
}

impl std::fmt::Display for XMLErrorLevel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match *self {
            Self::FatalError => write!(f, "fatal error"),
            Self::Error => write!(f, "error"),
            Self::Warning => write!(f, "warning"),
        }
    }
}

/// Error domain.
///
/// This helps identify which part of the process caused the error.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum XMLErrorDomain {
    /// XML parser errors.
    Parser,
    /// Namespace error.
    Namespace,
    /// DTD validation error.
    DTDValid,
    /// RELAX NG schema parsing error.
    RngParser,
    /// RELAX NG Compact Syntax schema parsing error.
    RncParser,
    /// RELAX NG validation error.
    RngValid,
    /// XML Canonicalization error.
    C14N,
    /// XInclude error.
    XInclude,
}

impl std::fmt::Display for XMLErrorDomain {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match *self {
            Self::Parser => write!(f, "parser"),
            Self::Namespace => write!(f, "namespace"),
            Self::DTDValid => write!(f, "dtd-valid"),
            Self::RngParser => write!(f, "relaxng-parser"),
            Self::RncParser => write!(f, "relaxng-compact-syntax-parser"),
            Self::RngValid => write!(f, "relaxng-valid"),
            Self::C14N => write!(f, "c14n"),
            Self::XInclude => write!(f, "xinclude"),
        }
    }
}

/// Error codes.
#[derive(Debug, Clone)]
pub enum XMLError {
    // general errors
    InternalError,
    UnsupportedError,
    // parser errors
    XMLParseError(ParseError),
    // I/O errors
    IOError(Arc<std::io::Error>),
    // encoding errors
    EncodeError(EncodeError),
    EncoderUnknownError,
    DecodeError(DecodeError),
    DecoderUnknownError,
    // URI errors
    URIParseError(ParseRIError),
    URIBaseURINotAbsolute,
    URIBaseURINotFound,
    // Tree errors
    TreeError(XMLTreeError),
    // XPath errors
    XPathError(XPathError),
    // Catalog errors
    CatalogInvalidPublicID,
    CatalogResourceFailure,
    // RELAX NG parsing errors
    RngParseError(RngParseError),
    // RELAX NG validation errors
    RngValidError(RngValidError),
    // RELAX NG Compact Syntax parsing errors
    RncParseError(RncParseError),
    // XPointer errors
    XPointerParseError(XPointerParseError),
    // XInclude errors
    XIncludeError(XIncludeError),
    // C14N errors
    C14NUnresolvableEntityReference,
}

impl std::fmt::Display for XMLError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}

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

impl From<ParseError> for XMLError {
    fn from(value: ParseError) -> Self {
        XMLError::XMLParseError(value)
    }
}

impl From<std::io::Error> for XMLError {
    fn from(value: std::io::Error) -> Self {
        Self::IOError(Arc::new(value))
    }
}

impl From<EncodeError> for XMLError {
    fn from(value: EncodeError) -> Self {
        Self::EncodeError(value)
    }
}

impl From<DecodeError> for XMLError {
    fn from(value: DecodeError) -> Self {
        Self::DecodeError(value)
    }
}

impl From<ParseRIError> for XMLError {
    fn from(value: ParseRIError) -> Self {
        Self::URIParseError(value)
    }
}

impl From<XMLTreeError> for XMLError {
    fn from(value: XMLTreeError) -> Self {
        Self::TreeError(value)
    }
}

impl From<XPathError> for XMLError {
    fn from(value: XPathError) -> Self {
        Self::XPathError(value)
    }
}

impl From<XPathCompileError> for XMLError {
    fn from(value: XPathCompileError) -> Self {
        XPathError::from(value).into()
    }
}

impl From<XPointerParseError> for XMLError {
    fn from(value: XPointerParseError) -> Self {
        XMLError::XPointerParseError(value)
    }
}

impl From<XIncludeError> for XMLError {
    fn from(value: XIncludeError) -> Self {
        XMLError::XIncludeError(value)
    }
}

impl From<RngParseError> for XMLError {
    fn from(value: RngParseError) -> Self {
        XMLError::RngParseError(value)
    }
}

impl From<RngValidError> for XMLError {
    fn from(value: RngValidError) -> Self {
        XMLError::RngValidError(value)
    }
}

impl From<RncParseError> for XMLError {
    fn from(value: RncParseError) -> Self {
        XMLError::RncParseError(value)
    }
}