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

//! XPT version definitions.
//!
//! This module defines the [`XptVersion`] enum for selecting the XPT format version.

/// The XPT format version.
///
/// Currently, only [`XptVersion::V5`] is fully implemented. [`XptVersion::V8`] is API-ready but not yet implemented.
///
/// # Versions
///
/// - [`XptVersion::V5`] - Traditional SAS Transport format with 8-byte names, 40-byte labels
/// - [`XptVersion::V8`] - Extended format with 32-byte names, 256-byte labels (not yet implemented)
///
/// # Example
///
/// ```
/// use xportrs::XptVersion;
///
/// let version = XptVersion::default();
/// if version.is_v5() {
///     println!("Using XPT v5 with max {} byte variable names",
///         version.max_variable_name_len());
/// }
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub enum XptVersion {
    /// XPT Version 5 (SAS Transport format).
    ///
    /// This is the traditional format used for CDISC submissions.
    /// - 8-byte variable names
    /// - 40-byte labels
    /// - IBM floating-point encoding
    #[default]
    V5,

    /// XPT Version 8 (extended format).
    ///
    /// **Not yet implemented.** This version supports:
    /// - Longer variable names (up to 32 bytes)
    /// - Longer labels (up to 256 bytes)
    /// - Different header structure
    V8,
}

impl XptVersion {
    /// Returns `true` if this is [`XptVersion::V5`].
    #[must_use]
    pub const fn is_v5(&self) -> bool {
        matches!(self, Self::V5)
    }

    /// Returns `true` if this is [`XptVersion::V8`].
    #[must_use]
    pub const fn is_v8(&self) -> bool {
        matches!(self, Self::V8)
    }

    /// Returns the maximum variable name length for this version.
    #[must_use]
    pub const fn max_variable_name_len(&self) -> usize {
        match self {
            Self::V5 => 8,
            Self::V8 => 32,
        }
    }

    /// Returns the maximum label length for this version.
    #[must_use]
    pub const fn max_label_len(&self) -> usize {
        match self {
            Self::V5 => 40,
            Self::V8 => 256,
        }
    }

    /// Returns `true` if this version is implemented.
    #[must_use]
    pub const fn is_implemented(&self) -> bool {
        matches!(self, Self::V5)
    }
}

impl std::fmt::Display for XptVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::V5 => write!(f, "v5"),
            Self::V8 => write!(f, "v8"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_version_properties() {
        assert!(XptVersion::V5.is_v5());
        assert!(!XptVersion::V5.is_v8());
        assert!(XptVersion::V5.is_implemented());

        assert!(!XptVersion::V8.is_v5());
        assert!(XptVersion::V8.is_v8());
        assert!(!XptVersion::V8.is_implemented());
    }

    #[test]
    fn test_version_limits() {
        assert_eq!(XptVersion::V5.max_variable_name_len(), 8);
        assert_eq!(XptVersion::V5.max_label_len(), 40);
        assert_eq!(XptVersion::V8.max_variable_name_len(), 32);
        assert_eq!(XptVersion::V8.max_label_len(), 256);
    }
}