caldata 0.16.2

Ical/Vcard parser 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

mod ical;
mod property;
use std::collections::BTreeMap;

pub use crate::component::ical::component::{IcalCalendar, IcalEvent};
pub use crate::component::vcard::component::VcardContact;
pub use crate::parser::ContentLine;

///
/// Emits the content of the Component in ical-format.
///
pub trait Emitter {
    /// creates a textual-representation of this object and all it's properties
    /// in ical-format.
    fn generate(&self) -> String;
}

impl<K, T: Emitter> Emitter for BTreeMap<K, T> {
    fn generate(&self) -> String {
        self.values().map(Emitter::generate).collect()
    }
}

impl<T: Emitter> Emitter for Vec<T> {
    fn generate(&self) -> String {
        self.iter().map(Emitter::generate).collect()
    }
}

mod helper {
    /// Creates a param for a [`ContentLine`](property/struct.ContentLine.html).
    ///
    /// # Example
    /// ```
    /// # #[macro_use] extern crate caldata;
    /// let param : (String, Vec<String>) = ical_param!("param2", "pvalue1", "pvalue2");
    /// assert_eq!(format!("{:?}", param), "(\"param2\", [\"pvalue1\", \"pvalue2\"])");
    /// ```
    #[macro_export]
    macro_rules! ical_param {
        ($key:literal, $($prop:expr),+) => {
            (String::from($key), vec![$(String::from($prop),)+])
        };
    }

    /// Creates a [`ContentLine`](property/struct.ContentLine.html) for use with
    /// [IcalCalendarBuilder](generator/struct.IcalCalendarBuilder.html),
    /// [IcalEventBuilder](generator/struct.IcalEventBuilder.html),
    /// [IcalVcardBuilder](generator/struct.IcalVcardBuilder.html),
    /// `IcalTodo`, `IcalJournal` ...
    ///
    /// # Example
    /// ```
    /// # #[macro_use] extern crate caldata;
    /// # use caldata::parser::ContentLine;
    /// let prop = ical_property!(
    ///             "NAME",
    ///             "value",
    ///             ical_param!("param2", "pvalue1", "pvalue2"),
    ///             ical_param!("param3", "pvalue3")
    ///         );
    /// let debug_output = "ContentLine { \
    ///     name: \"NAME\", \
    ///     params: ContentLineParams([\
    ///         (\"param2\", [\"pvalue1\", \"pvalue2\"]), \
    ///         (\"param3\", [\"pvalue3\"])\
    ///     ]), \
    ///     value: \"value\" \
    /// }";
    /// similar_asserts::assert_eq!(debug_output, format!("{:?}", prop));
    /// ```
    #[macro_export]
    macro_rules! ical_property {
        ($name:literal, $value:expr) => {
            ContentLine {
                name: String::from($name),
                value: $value.into(),
                params: vec![].into(),
            }
        };
        ($name:literal, $value:expr, $($params:expr),+) => {
            ContentLine {
                name: String::from($name),
                value: String::from($value),
                params: vec![$($params,)+].into(),
            }
        };
    }
}