xportrs 0.0.8

CDISC-compliant XPT file generation and parsing library for Rust
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
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Error types for xportrs.
//!
//! This module defines the [`Error`] enum which represents all possible
//! errors that can occur during XPT file reading, writing, and validation.

use std::path::PathBuf;

use crate::xpt::XptVersion;

/// The main error type for xportrs operations.
///
/// This enum covers all error conditions that can arise when working with XPT files,
/// including I/O errors, format violations, validation failures, and unsupported features.
#[derive(thiserror::Error, Debug)]
#[non_exhaustive]
pub enum Error {
    /// An I/O error occurred while reading or writing.
    #[error("io error: {0}")]
    Io(#[from] std::io::Error),

    /// The requested [`XptVersion`] is not supported.
    #[error("unsupported XPT version: {version:?}")]
    UnsupportedVersion {
        /// The unsupported [`XptVersion`] that was requested.
        version: XptVersion,
    },

    /// The XPT file is corrupt or malformed.
    #[error("corrupt xpt: {message}")]
    Corrupt {
        /// A description of what makes the file corrupt.
        message: String,
    },

    /// The schema or structure is invalid.
    #[error("invalid schema: {message}")]
    InvalidSchema {
        /// A description of what makes the schema invalid.
        message: String,
    },

    /// Validation failed with one or more errors.
    #[error("validation failed: {message}")]
    ValidationFailed {
        /// A description of the validation failure.
        message: String,
    },

    /// A metadata-related error occurred.
    #[error("metadata error: {message}")]
    Metadata {
        /// A description of the metadata error.
        message: String,
    },

    /// The requested member (dataset) was not found in the XPT file.
    #[error("member not found: {domain_code}")]
    MemberNotFound {
        /// The domain code that was not found.
        domain_code: String,
    },

    /// Column length mismatch - all columns must have the same number of rows.
    #[error(
        "column length mismatch: column '{column_name}' has {actual} rows, expected {expected}"
    )]
    ColumnLengthMismatch {
        /// Name of the column with mismatched length.
        column_name: String,
        /// The actual number of rows in the column.
        actual: usize,
        /// The expected number of rows.
        expected: usize,
    },

    /// A file path error occurred.
    #[error("path error: {message} (path: {path:?})")]
    Path {
        /// A description of the path error.
        message: String,
        /// The problematic path.
        path: PathBuf,
    },

    /// An encoding error occurred during text conversion.
    #[error("encoding error: {message}")]
    Encoding {
        /// A description of the encoding error.
        message: String,
    },

    /// A Polars conversion error occurred.
    #[cfg(feature = "polars")]
    #[error("polars error: {message}")]
    Polars {
        /// A description of the Polars error.
        message: String,
    },
}

impl Error {
    /// Creates a new [`Error::Corrupt`] error.
    #[must_use]
    pub fn corrupt(message: impl Into<String>) -> Self {
        Self::Corrupt {
            message: message.into(),
        }
    }

    /// Creates a new [`Error::InvalidSchema`] error.
    #[must_use]
    pub fn invalid_schema(message: impl Into<String>) -> Self {
        Self::InvalidSchema {
            message: message.into(),
        }
    }

    /// Creates a new [`Error::ValidationFailed`] error.
    #[must_use]
    pub fn validation_failed(message: impl Into<String>) -> Self {
        Self::ValidationFailed {
            message: message.into(),
        }
    }

    /// Creates a new [`Error::Metadata`] error.
    #[must_use]
    pub fn metadata(message: impl Into<String>) -> Self {
        Self::Metadata {
            message: message.into(),
        }
    }

    /// Creates a new [`Error::Encoding`] error.
    #[must_use]
    pub fn encoding(message: impl Into<String>) -> Self {
        Self::Encoding {
            message: message.into(),
        }
    }
}

/// A type alias for `Result<T, `[`Error`]`>`.
pub type Result<T> = std::result::Result<T, Error>;