openprxl 0.1.0

A Rust spreadsheet library inspired by Python's openpyxl
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

//! Font styling.

/// A font description.
#[derive(Debug, Clone, Default)]
pub struct Font {
    pub(crate) name: Option<String>,
    pub(crate) size: Option<f64>,
    pub(crate) bold: bool,
    pub(crate) italic: bool,
    pub(crate) underline: Option<UnderlineStyle>,
    pub(crate) strike: bool,
    pub(crate) color: Option<String>,
    pub(crate) family: Option<u8>,
    pub(crate) scheme: Option<String>,
}

impl PartialEq for Font {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name
            && self.size.map(|f| f.to_bits()) == other.size.map(|f| f.to_bits())
            && self.bold == other.bold
            && self.italic == other.italic
            && self.underline == other.underline
            && self.strike == other.strike
            && self.color == other.color
            && self.family == other.family
            && self.scheme == other.scheme
    }
}

impl Eq for Font {}

impl std::hash::Hash for Font {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.name.hash(state);
        self.size.map(|f| f.to_bits()).hash(state);
        self.bold.hash(state);
        self.italic.hash(state);
        self.underline.hash(state);
        self.strike.hash(state);
        self.color.hash(state);
        self.family.hash(state);
        self.scheme.hash(state);
    }
}

impl Font {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn name<S: Into<String>>(mut self, name: S) -> Self {
        self.name = Some(name.into());
        self
    }

    pub fn size(mut self, size: f64) -> Self {
        self.size = Some(size);
        self
    }

    pub fn bold(mut self, bold: bool) -> Self {
        self.bold = bold;
        self
    }

    pub fn italic(mut self, italic: bool) -> Self {
        self.italic = italic;
        self
    }

    pub fn underline(mut self, underline: UnderlineStyle) -> Self {
        self.underline = Some(underline);
        self
    }

    pub fn strike(mut self, strike: bool) -> Self {
        self.strike = strike;
        self
    }

    /// Set the font color as an RGB hex string such as `FF0000`.
    pub fn color<S: Into<String>>(mut self, color: S) -> Self {
        self.color = Some(color.into());
        self
    }

    pub fn family(mut self, family: u8) -> Self {
        self.family = Some(family);
        self
    }

    pub fn scheme<S: Into<String>>(mut self, scheme: S) -> Self {
        self.scheme = Some(scheme.into());
        self
    }

    pub fn get_name(&self) -> Option<&str> {
        self.name.as_deref()
    }

    pub fn get_size(&self) -> Option<f64> {
        self.size
    }

    pub fn is_bold(&self) -> bool {
        self.bold
    }

    pub fn is_italic(&self) -> bool {
        self.italic
    }

    pub fn get_underline(&self) -> Option<&UnderlineStyle> {
        self.underline.as_ref()
    }

    pub fn is_strike(&self) -> bool {
        self.strike
    }

    pub fn get_color(&self) -> Option<&str> {
        self.color.as_deref()
    }
}

/// Underline styles.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum UnderlineStyle {
    Single,
    Double,
    SingleAccounting,
    DoubleAccounting,
}

impl std::fmt::Display for UnderlineStyle {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            UnderlineStyle::Single => write!(f, "single"),
            UnderlineStyle::Double => write!(f, "double"),
            UnderlineStyle::SingleAccounting => write!(f, "singleAccounting"),
            UnderlineStyle::DoubleAccounting => write!(f, "doubleAccounting"),
        }
    }
}