anyxml 0.12.1

//! General error types.

use std::sync::Arc;

use crate::{
    encoding::{DecodeError, EncodeError},
    relaxng::RncParseError,
    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
    ParserUnknownError,
    ParserUnsupportedEncoding,
    ParserUnsupportedXMLVersion,
    ParserTooLongXMLVersionNumber,
    PraserTooLongEncodingName,
    ParserEmptyNmtoken,
    ParserEmptyName,
    ParserEmptyNCName,
    ParserEmptyQName,
    ParserEmptyQNamePrefix,
    ParserEmptyQNameLocalPart,
    ParserEmptyNmtokens,
    ParserEmptyNames,
    ParserInvalidNameStartChar,
    ParserInvalidNameChar,
    ParserInvalidNCNameStartChar,
    ParserInvalidNCNameChar,
    ParserInvalidQNameSeparator,
    ParserIncorrectLiteralQuotation,
    ParserInvalidSystemLiteral,
    ParserSystemLiteralWithFragment,
    ParserInvalidPubidLiteral,
    ParserInvalidAttValue,
    ParserInvalidExternalID,
    ParserInvalidCharacter,
    ParserInvalidXMLDecl,
    ParserInvalidTextDecl,
    ParserInvalidXMLVersion,
    ParserInvalidEncodingDecl,
    ParserInvalidEncodingName,
    ParserInvalidSDDecl,
    ParserInvalidComment,
    ParserInvalidCDSect,
    ParserInvalidStandaloneDocument,
    ParserInvalidProcessingInstruction,
    ParserUnacceptableCatalogPIPosition,
    ParserInvalidCatalogPIAttribute,
    ParserUnacceptablePITarget,
    ParserUnacceptablePatternInCharData,
    ParserInvalidDoctypeDecl,
    ParserInvalidElementDecl,
    ParserDuplicateElementDecl,
    ParserAmbiguousElementContentModel,
    ParserDuplicateMixedContent,
    ParserInvalidAttlistDecl,
    ParserMismatchXMLIDAttributeType,
    ParserDuplicateAttlistDecl,
    ParserDuplicateTokensInAttlistDecl,
    ParserMultipleIDAttributePerElement,
    ParserInvalidIDAttributeValue,
    ParserInvalidIDREFAttributeValue,
    ParserNotationAttlistDeclOnEmptyElement,
    ParserSyntaxticallyIncorrectAttributeDefault,
    ParserInvalidEntityDecl,
    ParserIncorrectPredefinedEntityDecl,
    ParserDuplicateEntityDecl,
    ParserInvalidNotationDecl,
    ParserDuplicateNotationDecl,
    ParserUndeclaredNotation,
    ParserInvalidConditionalSect,
    ParserInvalidStartOrEmptyTag,
    ParserInvalidEndTag,
    ParserUnclosedStartTag,
    ParserMismatchElementType,
    ParserMismatchElementContentModel,
    ParserUndeclaredElement,
    ParserInvalidAttribute,
    ParserUndeclaredAttribute,
    ParserDuplicateAttributes,
    ParserDuplicateIDAttribute,
    ParserUnresolvableIDReference,
    ParserMultipleNotationAttributePerElement,
    ParserUnacceptableNotationAttribute,
    ParserUnacceptableEnumerationAttribute,
    ParserMismatchFixedDefaultAttributeValue,
    ParserRequiredAttributeNotFound,
    ParserUnacceptableXMLSpaceAttribute,
    ParserInvalidCharacterReference,
    ParserInvalidEntityReference,
    ParserEntityNotFound,
    ParserEntityRecursion,
    ParserEntityIncorrectNesting,
    ParserUndeclaredEntityReference,
    ParserNamespaceNameNotURI,
    ParserNamespaceNameNotAbsoluteURI,
    ParserUnacceptableNamespaceName,
    ParserUndefinedNamespace,
    ParserUnexpectedDocumentContent,
    ParserUnexpectedEOF,
    // 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 errors
    RngParseUnacceptablePattern,
    RngParseUnacceptableCombine,
    RngParseUnacceptableAttribute,
    RngParseUnacceptableString,
    RngParseInvalidNCName,
    RngParseInvalidQName,
    RngParseInvalidAnyURI,
    RngParseUnresolvableNamespacePrefix,
    RngParseUnresolvableDatatype,
    RngParseUnresolvableDatatypeLibrary,
    RngParseUnresolvableRefName,
    RngParseUnresolvableParentRefName,
    RngParseDatatypeLibraryURINotAbsolute,
    RngParseInsufficientAttribute,
    RngParseInsufficientStartInInclude,
    RngParseInsufficientDefineInInclude,
    RngParseExternalRefParseFailure,
    RngParseExternalRefLoop,
    RngParseIncludeParseFailure,
    RngParseIncludeLoop,
    RngParseHRefIncludeFragment,
    RngParseMultipleStartWithoutCombine,
    RngParseMultipleDefineWithoutCombine,
    RngParseStartNotFoundInGrammar,
    RngParseRefLoop,
    RngParseProhibitedPath,
    RngParseUngroupablePattern,
    RngParseConflictElementNameClass,
    RngParseConflictAttributeNameClass,
    RngParseUnrepeatedAttributeWithInfiniteNameClass,
    RngParseUnknownError,
    RngValidNotAllowed,
    RngValidEmpty,
    RngValidText,
    RngValidData,
    RngValidValue,
    RngValidList,
    RngValidAttribute,
    RngValidGroup,
    RngValidInterleave,
    RngValidRef,
    RngValidElement,
    RngValidOneOrMore,
    RngValidUnknownError,
    // 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<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<RncParseError> for XMLError {
    fn from(value: RncParseError) -> Self {
        XMLError::RncParseError(value)
    }
}