types 0.1.0

Shared types and DTOs for the Liturgy workspace.
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
145

use std::fmt::Debug;

use chrono::NaiveDate;
use serde::{Serialize, ser::SerializeStruct as _};

use crate::{ArcStr, LiturgicalUnit};

pub trait DayRank: Clone + std::fmt::Debug + Serialize + Send + Sync {
    fn as_str(&self) -> &str;
}

#[derive(Clone, Debug, Serialize)]
pub struct TrivialDayRank(pub ArcStr);

impl DayRank for TrivialDayRank {
    fn as_str(&self) -> &str {
        self.0.as_ref()
    }
}

#[derive(Clone, Debug)]
pub struct DayRank62 {
    pub office: DayRank62Office,
    pub description: ArcStr,
}

impl Serialize for DayRank62 {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

#[derive(Clone, Debug, Serialize)]
pub enum DayRank62Office {
    Sunday,
    Feastial,
    Semifestial,
    Ordinary,
    Ferial,
}

impl DayRank for DayRank62 {
    fn as_str(&self) -> &str {
        self.description.as_ref()
    }
}

impl DayRank62 {
    #[must_use]
    pub fn new(office: DayRank62Office, description: &str) -> Self {
        DayRank62 {
            office,
            description: ArcStr::from(description),
        }
    }

    #[must_use]
    pub fn has_first_vespers(&self) -> bool {
        matches!(
            self.office,
            DayRank62Office::Sunday | DayRank62Office::Feastial
        )
    }
}

#[derive(Clone, Default)]
pub enum ConcuringVespersAction {
    #[default]
    Use,
    Commemorate,
    UseCommemorateSelf,
}

impl Debug for ConcuringVespersAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ConcuringVespersAction::Use => write!(f, "Vespers of Following"),
            ConcuringVespersAction::Commemorate => write!(f, "Commemorate Vespers of Following"),
            ConcuringVespersAction::UseCommemorateSelf => {
                write!(f, "Vespers of Following, Commemorate Own Vespers")
            }
        }
    }
}

#[derive(Clone, Debug, Serialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum CommemorationType {
    Optional,
    Lauds,
    LaudsAndVespers,
    PeterAndPaulSpecial,
}

#[derive(Debug, Clone)]
pub struct DayDescription<R: DayRank> {
    pub date: NaiveDate,

    pub day_in_season: ArcStr,

    pub day: LiturgicalUnit<R>,
    pub commemorations: Vec<(LiturgicalUnit<R>, CommemorationType)>,
    pub concuring_vespers: Option<(LiturgicalUnit<R>, ConcuringVespersAction)>,
    pub underlying_octave: Option<String>,

    pub season: ArcStr,
}

impl<R> DayDescription<R>
where
    R: DayRank,
{
    pub fn add_concuring_vespers(
        self,
        vespers: LiturgicalUnit<R>,
        action: ConcuringVespersAction,
    ) -> Self {
        Self {
            concuring_vespers: Some((vespers, action)),
            ..self
        }
    }
}

impl<R> Serialize for DayDescription<R>
where
    R: DayRank,
{
    // Custom serialization to handle LiturgicalUnit serialization
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        // Keep external serialized shape stable (date, day_in_season, day_rank, day,
        // commemorations)
        let mut state = serializer.serialize_struct("DayDescription", 5)?;
        state.serialize_field("date", &self.date.to_string())?;
        state.serialize_field("day_in_season", self.day_in_season.as_ref())?;
        state.serialize_field("day", &self.day)?;
        state.serialize_field("commemorations", &self.commemorations)?;
        state.end()
    }
}