fastxml 0.8.1

A fast, memory-efficient XML library with XPath and XSD validation support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! Error types for the transform module.

use std::io;

use super::xpath_analyze::NotStreamableReason;

// Re-export ErrorLocation from the main error module
pub use crate::error::ErrorLocation;

/// Errors that can occur during XML transformation.
#[derive(Debug, thiserror::Error)]
pub enum TransformError {
    /// XPath expression is invalid or unsupported
    #[error("invalid xpath: {0}")]
    InvalidXPath(String),

    /// XML parsing error during transformation
    #[error("xml parse error: {0}")]
    XmlParse(String),

    /// XML parsing error with location information
    #[error("xml parse error: {message} ({location})")]
    XmlParseWithLocation {
        /// Error message
        message: String,
        /// Error location
        location: ErrorLocation,
    },

    /// IO error during output
    #[error("io error: {0}")]
    Io(#[from] io::Error),

    /// UTF-8 encoding error
    #[error("utf8 error: {0}")]
    Utf8(#[from] std::str::Utf8Error),

    /// Serialization error
    #[error("serialization error: {0}")]
    Serialization(String),

    /// Node modification error
    #[error("modification error: {0}")]
    Modification(String),

    /// XPath is not streamable and fallback is disabled
    #[error(
        "xpath '{xpath}' is not streamable: {reason}. Use .allow_fallback() to enable two-pass processing, or use a streamable XPath pattern."
    )]
    NotStreamable {
        /// The XPath expression
        xpath: String,
        /// The reason why it's not streamable
        reason: NotStreamableReason,
    },

    /// General error from the crate
    #[error(transparent)]
    Other(#[from] crate::error::Error),
}

impl From<quick_xml::Error> for TransformError {
    fn from(err: quick_xml::Error) -> Self {
        TransformError::XmlParse(err.to_string())
    }
}

/// Result type for transform operations.
pub type TransformResult<T> = std::result::Result<T, TransformError>;