libpostal-rs 0.1.3

Static Rust bindings for libpostal - international address parsing and normalization
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Error types and handling for libpostal-rs.

/// Result type alias for libpostal operations.
pub type Result<T> = std::result::Result<T, Error>;

/// Error types for libpostal operations.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// Initialization failed
    #[error("Failed to initialize libpostal: {message}")]
    InitializationFailed {
        /// Error message from libpostal
        message: String,
    },

    /// Data management errors
    #[error("Data error: {message}")]
    DataError {
        /// Error message
        message: String,
    },

    /// Parsing errors
    #[error("Parse error: {message}")]
    ParseError {
        /// Error message
        message: String,
    },

    /// Normalization errors
    #[error("Normalization error: {message}")]
    NormalizationError {
        /// Error message
        message: String,
    },

    /// FFI errors
    #[error("FFI error: {message}")]
    FfiError {
        /// Error message
        message: String,
    },

    /// I/O errors
    #[error("I/O error: {source}")]
    IoError {
        /// Source error
        #[from]
        source: std::io::Error,
    },

    /// Network errors (for data downloads)
    #[cfg(feature = "runtime-data")]
    #[error("Network error: {message}")]
    NetworkError {
        /// Error message
        message: String,
    },
}

impl Error {
    /// Create a new initialization error
    pub fn initialization_failed(message: impl Into<String>) -> Self {
        Self::InitializationFailed {
            message: message.into(),
        }
    }

    /// Create a new data error
    pub fn data_error(message: impl Into<String>) -> Self {
        Self::DataError {
            message: message.into(),
        }
    }

    /// Create a new parse error
    pub fn parse_error(message: impl Into<String>) -> Self {
        Self::ParseError {
            message: message.into(),
        }
    }

    /// Create a new normalization error
    pub fn normalization_error(message: impl Into<String>) -> Self {
        Self::NormalizationError {
            message: message.into(),
        }
    }

    /// Create a new FFI error
    pub fn ffi_error(message: impl Into<String>) -> Self {
        Self::FfiError {
            message: message.into(),
        }
    }

    /// Create a new network error
    #[cfg(feature = "runtime-data")]
    pub fn network_error(message: impl Into<String>) -> Self {
        Self::NetworkError {
            message: message.into(),
        }
    }
}