rfc5545-types 0.1.0

iCalendar (RFC 5545) recurrence rule and component types
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

//! Types for describing request statuses.

/// A value of the REQUEST-STATUS property (RFC 5545 §3.8.8.3).
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RequestStatus {
    /// The hierarchical status code.
    pub code: StatusCode,
    /// A human-readable description of the status.
    pub description: Box<str>,
    /// Optional additional data about the status.
    pub exception_data: Option<Box<str>>,
}

impl std::fmt::Display for RequestStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{};{}", self.code, self.description)?;
        if let Some(data) = &self.exception_data {
            write!(f, ";{data}")?;
        }
        Ok(())
    }
}

/// A hierarchical status code (e.g. `2.0`, `3.1.2`).
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct StatusCode {
    /// The status class (1–5).
    pub class: Class,
    /// The major status number within the class.
    pub major: u8,
    /// The optional minor status number.
    pub minor: Option<u8>,
}

impl std::fmt::Display for StatusCode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}.{}", self.class.as_u8(), self.major)?;
        if let Some(minor) = self.minor {
            write!(f, ".{minor}")?;
        }
        Ok(())
    }
}

/// The class of a [`StatusCode`].
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Class {
    /// Preliminary success.
    ///
    /// The request has been processed but completion is pending.
    C1,
    /// Complete success.
    ///
    /// The request has been completed successfully, although based on the specific status code a
    /// fallback may have been taken.
    C2,
    /// Client error.
    ///
    /// The request was not successful, due to a syntactic or semantic error in the
    /// client-formatted request. The request should not be retried until the error condition in
    /// the request has been corrected.
    C3,
    /// Scheduling error.
    ///
    /// The request was not successful due to a semantic issue with the calendaring and scheduling
    /// service not directly related to the request itself.
    C4,
    /// Service error.
    ///
    /// The request was not successful because a service either did not exist, was not available,
    /// or was unsupported.
    C5,
}

impl Class {
    /// Returns the numeric value of this class (1–5).
    pub const fn as_u8(self) -> u8 {
        match self {
            Class::C1 => 1,
            Class::C2 => 2,
            Class::C3 => 3,
            Class::C4 => 4,
            Class::C5 => 5,
        }
    }

    /// Creates a `Class` from a numeric value (1–5), returning `None` if out of range.
    pub const fn from_u8(value: u8) -> Option<Self> {
        match value {
            1 => Some(Class::C1),
            2 => Some(Class::C2),
            3 => Some(Class::C3),
            4 => Some(Class::C4),
            5 => Some(Class::C5),
            _ => None,
        }
    }
}