ical/parser/ical/
component.rs

1// Sys mods
2use std::cell::RefCell;
3use std::io::BufRead;
4
5#[cfg(feature = "serde-derive")]
6extern crate serde;
7
8// Internal mods
9use crate::parser::Component;
10use crate::parser::ParserError;
11use crate::property::{Property, PropertyParser};
12
13#[derive(Debug, Clone, Default)]
14#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
15/// An ICAL calendar.
16pub struct IcalCalendar {
17    pub properties: Vec<Property>,
18    pub events: Vec<IcalEvent>,
19    pub alarms: Vec<IcalAlarm>,
20    pub todos: Vec<IcalTodo>,
21    pub journals: Vec<IcalJournal>,
22    pub free_busys: Vec<IcalFreeBusy>,
23    pub timezones: Vec<IcalTimeZone>,
24}
25
26impl IcalCalendar {
27    pub fn new() -> IcalCalendar {
28        IcalCalendar {
29            properties: Vec::new(),
30            events: Vec::new(),
31            alarms: Vec::new(),
32            todos: Vec::new(),
33            journals: Vec::new(),
34            free_busys: Vec::new(),
35            timezones: Vec::new(),
36        }
37    }
38}
39
40impl Component for IcalCalendar {
41    fn add_property(&mut self, property: Property) {
42        self.properties.push(property);
43    }
44
45    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
46        self.properties.iter().find(|p| p.name == name)
47    }
48
49    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
50        self.properties.iter_mut().find(|p| p.name == name)
51    }
52
53    fn add_sub_component<B: BufRead>(
54        &mut self,
55        value: &str,
56        line_parser: &RefCell<PropertyParser<B>>,
57    ) -> Result<(), ParserError> {
58        match value {
59            "VALARM" => {
60                let mut alarm = IcalAlarm::new();
61                alarm.parse(line_parser)?;
62                self.alarms.push(alarm);
63            }
64            "VEVENT" => {
65                let mut event = IcalEvent::new();
66                event.parse(line_parser)?;
67                self.events.push(event);
68            }
69            "VTODO" => {
70                let mut todo = IcalTodo::new();
71                todo.parse(line_parser)?;
72                self.todos.push(todo);
73            }
74            "VJOURNAL" => {
75                let mut journal = IcalJournal::new();
76                journal.parse(line_parser)?;
77                self.journals.push(journal);
78            }
79            "VFREEBUSY" => {
80                let mut free_busy = IcalFreeBusy::new();
81                free_busy.parse(line_parser)?;
82                self.free_busys.push(free_busy);
83            }
84            "VTIMEZONE" => {
85                let mut timezone = IcalTimeZone::new();
86                timezone.parse(line_parser)?;
87                self.timezones.push(timezone);
88            }
89            _ => return Err(ParserError::InvalidComponent),
90        };
91
92        Ok(())
93    }
94}
95
96#[derive(Debug, Clone, Default)]
97#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
98pub struct IcalAlarm {
99    pub properties: Vec<Property>,
100}
101
102impl IcalAlarm {
103    pub fn new() -> IcalAlarm {
104        IcalAlarm {
105            properties: Vec::new(),
106        }
107    }
108}
109
110impl Component for IcalAlarm {
111    fn add_property(&mut self, property: Property) {
112        self.properties.push(property);
113    }
114
115    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
116        self.properties.iter().find(|p| p.name == name)
117    }
118
119    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
120        self.properties.iter_mut().find(|p| p.name == name)
121    }
122
123    fn add_sub_component<B: BufRead>(
124        &mut self,
125        _: &str,
126        _: &RefCell<PropertyParser<B>>,
127    ) -> Result<(), ParserError> {
128        Err(ParserError::InvalidComponent)
129    }
130}
131
132#[derive(Debug, Clone, Default)]
133#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
134pub struct IcalEvent {
135    pub properties: Vec<Property>,
136    pub alarms: Vec<IcalAlarm>,
137}
138
139impl IcalEvent {
140    pub fn new() -> IcalEvent {
141        IcalEvent {
142            properties: Vec::new(),
143            alarms: Vec::new(),
144        }
145    }
146}
147
148impl Component for IcalEvent {
149    fn add_property(&mut self, property: Property) {
150        self.properties.push(property);
151    }
152
153    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
154        self.properties.iter().find(|p| p.name == name)
155    }
156
157    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
158        self.properties.iter_mut().find(|p| p.name == name)
159    }
160
161    fn add_sub_component<B: BufRead>(
162        &mut self,
163        value: &str,
164        line_parser: &RefCell<PropertyParser<B>>,
165    ) -> Result<(), ParserError> {
166        match value {
167            "VALARM" => {
168                let mut alarm = IcalAlarm::new();
169                alarm.parse(line_parser)?;
170                self.alarms.push(alarm);
171            }
172            _ => return Err(ParserError::InvalidComponent),
173        };
174
175        Ok(())
176    }
177}
178
179#[derive(Debug, Clone, Default)]
180#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
181pub struct IcalJournal {
182    pub properties: Vec<Property>,
183}
184
185impl IcalJournal {
186    pub fn new() -> IcalJournal {
187        IcalJournal {
188            properties: Vec::new(),
189        }
190    }
191}
192
193impl Component for IcalJournal {
194    fn add_property(&mut self, property: Property) {
195        self.properties.push(property);
196    }
197
198    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
199        self.properties.iter().find(|p| p.name == name)
200    }
201
202    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
203        self.properties.iter_mut().find(|p| p.name == name)
204    }
205
206    fn add_sub_component<B: BufRead>(
207        &mut self,
208        _: &str,
209        _: &RefCell<PropertyParser<B>>,
210    ) -> Result<(), ParserError> {
211        Err(ParserError::InvalidComponent)
212    }
213}
214
215#[derive(Debug, Clone, Default)]
216#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
217pub struct IcalTodo {
218    pub properties: Vec<Property>,
219    pub alarms: Vec<IcalAlarm>,
220}
221
222impl IcalTodo {
223    pub fn new() -> IcalTodo {
224        IcalTodo {
225            properties: Vec::new(),
226            alarms: Vec::new(),
227        }
228    }
229}
230
231impl Component for IcalTodo {
232    fn add_property(&mut self, property: Property) {
233        self.properties.push(property);
234    }
235
236    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
237        self.properties.iter().find(|p| p.name == name)
238    }
239
240    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
241        self.properties.iter_mut().find(|p| p.name == name)
242    }
243
244    fn add_sub_component<B: BufRead>(
245        &mut self,
246        value: &str,
247        line_parser: &RefCell<PropertyParser<B>>,
248    ) -> Result<(), ParserError> {
249        match value {
250            "VALARM" => {
251                let mut alarm = IcalAlarm::new();
252                alarm.parse(line_parser)?;
253                self.alarms.push(alarm);
254            }
255            _ => return Err(ParserError::InvalidComponent),
256        };
257
258        Ok(())
259    }
260}
261
262#[derive(Debug, Clone, Default)]
263#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
264pub struct IcalTimeZone {
265    pub properties: Vec<Property>,
266    pub transitions: Vec<IcalTimeZoneTransition>,
267}
268
269impl IcalTimeZone {
270    pub fn new() -> IcalTimeZone {
271        IcalTimeZone {
272            properties: Vec::new(),
273            transitions: Vec::new(),
274        }
275    }
276}
277
278impl Component for IcalTimeZone {
279    fn add_property(&mut self, property: Property) {
280        self.properties.push(property);
281    }
282
283    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
284        self.properties.iter().find(|p| p.name == name)
285    }
286
287    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
288        self.properties.iter_mut().find(|p| p.name == name)
289    }
290
291    fn add_sub_component<B: BufRead>(
292        &mut self,
293        value: &str,
294        line_parser: &RefCell<PropertyParser<B>>,
295    ) -> Result<(), ParserError> {
296        use self::IcalTimeZoneTransitionType::{DAYLIGHT, STANDARD};
297
298        match value {
299            "STANDARD" => {
300                let mut transition = IcalTimeZoneTransition::new(STANDARD);
301                transition.parse(line_parser)?;
302                self.transitions.push(transition);
303            }
304            "DAYLIGHT" => {
305                let mut transition = IcalTimeZoneTransition::new(DAYLIGHT);
306                transition.parse(line_parser)?;
307                self.transitions.push(transition);
308            }
309            _ => return Err(ParserError::InvalidComponent),
310        };
311
312        Ok(())
313    }
314}
315
316#[derive(Debug, Clone, Default)]
317#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
318pub enum IcalTimeZoneTransitionType {
319    #[default]
320    STANDARD,
321    DAYLIGHT,
322}
323
324#[derive(Debug, Clone, Default)]
325#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
326pub struct IcalTimeZoneTransition {
327    pub transition: IcalTimeZoneTransitionType,
328    pub properties: Vec<Property>,
329}
330
331impl IcalTimeZoneTransition {
332    pub fn new(transition: IcalTimeZoneTransitionType) -> IcalTimeZoneTransition {
333        IcalTimeZoneTransition {
334            transition,
335            properties: Vec::new(),
336        }
337    }
338}
339
340impl Component for IcalTimeZoneTransition {
341    fn add_property(&mut self, property: Property) {
342        self.properties.push(property);
343    }
344
345    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
346        self.properties.iter().find(|p| p.name == name)
347    }
348
349    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
350        self.properties.iter_mut().find(|p| p.name == name)
351    }
352
353    fn add_sub_component<B: BufRead>(
354        &mut self,
355        _: &str,
356        _: &RefCell<PropertyParser<B>>,
357    ) -> Result<(), ParserError> {
358        Err(ParserError::InvalidComponent)
359    }
360}
361
362#[derive(Debug, Clone, Default)]
363#[cfg_attr(feature = "serde-derive", derive(serde::Serialize, serde::Deserialize))]
364pub struct IcalFreeBusy {
365    pub properties: Vec<Property>,
366}
367
368impl IcalFreeBusy {
369    pub fn new() -> IcalFreeBusy {
370        IcalFreeBusy {
371            properties: Vec::new(),
372        }
373    }
374}
375
376impl Component for IcalFreeBusy {
377    fn add_property(&mut self, property: Property) {
378        self.properties.push(property);
379    }
380
381    fn get_property<'c>(&'c self, name: &str) -> Option<&'c Property> {
382        self.properties.iter().find(|p| p.name == name)
383    }
384
385    fn get_property_mut<'c>(&'c mut self, name: &str) -> Option<&'c mut Property> {
386        self.properties.iter_mut().find(|p| p.name == name)
387    }
388
389    fn add_sub_component<B: BufRead>(
390        &mut self,
391        _: &str,
392        _: &RefCell<PropertyParser<B>>,
393    ) -> Result<(), ParserError> {
394        Err(ParserError::InvalidComponent)
395    }
396}
ical/parser/ical/component.rs

ical/parser/ical/
component.rs
