umya-spreadsheet 2.3.3

umya-spreadsheet is a library written in pure Rust to read and write xlsx file.
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

// xdr:xfrm
use super::super::{Extents, Offset};
use crate::reader::driver::*;
use crate::writer::driver::*;
use crate::{BooleanValue, Int32Value};
use quick_xml::events::{BytesStart, Event};
use quick_xml::Reader;
use quick_xml::Writer;
use std::io::Cursor;

#[derive(Clone, Default, Debug)]
pub struct Transform {
    offset: Offset,
    extents: Extents,
    rotation: Int32Value,
    vertical_flip: BooleanValue,
    horizontal_flip: BooleanValue,
}

impl Transform {
    #[inline]
    pub fn get_offset(&self) -> &Offset {
        &self.offset
    }

    #[inline]
    pub fn get_offset_mut(&mut self) -> &mut Offset {
        &mut self.offset
    }

    #[inline]
    pub fn set_offset(&mut self, value: Offset) -> &mut Transform {
        self.offset = value;
        self
    }

    #[inline]
    pub fn get_extents(&self) -> &Extents {
        &self.extents
    }

    #[inline]
    pub fn get_extents_mut(&mut self) -> &mut Extents {
        &mut self.extents
    }

    #[inline]
    pub fn set_extents(&mut self, value: Extents) -> &mut Transform {
        self.extents = value;
        self
    }

    #[inline]
    pub fn get_rotation(&self) -> &i32 {
        self.rotation.get_value()
    }

    #[inline]
    pub fn set_rotation(&mut self, value: i32) {
        self.rotation.set_value(value);
    }

    #[inline]
    pub fn get_vertical_flip(&self) -> &bool {
        self.vertical_flip.get_value()
    }

    #[inline]
    pub fn set_vertical_flip(&mut self, value: bool) {
        self.vertical_flip.set_value(value);
    }

    #[inline]
    pub fn get_horizontal_flip(&self) -> &bool {
        self.horizontal_flip.get_value()
    }

    #[inline]
    pub fn set_horizontal_flip(&mut self, value: bool) {
        self.horizontal_flip.set_value(value);
    }

    pub(crate) fn set_attributes<R: std::io::BufRead>(
        &mut self,
        reader: &mut Reader<R>,
        e: &BytesStart,
    ) {
        set_string_from_xml!(self, e, rotation, "rot");
        set_string_from_xml!(self, e, horizontal_flip, "flipH");
        set_string_from_xml!(self, e, vertical_flip, "flipV");

        xml_read_loop!(
            reader,
            Event::Empty(ref e) => {
                match e.name().into_inner() {
                    b"a:off" => {
                        self.offset.set_attributes(reader, e);
                    }
                    b"a:ext" => {
                        self.extents.set_attributes(reader, e);
                    }
                    _ => (),
                }
            },
            Event::End(ref e) => {
                if  e.name().into_inner() == b"xdr:xfrm" {
                    return;
                }
            },
            Event::Eof => panic!("Error: Could not find {} end element", "xdr:xfrm")
        );
    }

    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
        // xdr:xfrm
        let mut attributes: Vec<(&str, &str)> = Vec::new();
        let rot = self.rotation.get_value_string();
        if self.rotation.has_value() {
            attributes.push(("rot", &rot));
        }
        if self.horizontal_flip.has_value() {
            attributes.push(("flipH", self.horizontal_flip.get_value_string()));
        }
        if self.vertical_flip.has_value() {
            attributes.push(("flipV", self.vertical_flip.get_value_string()));
        }
        write_start_tag(writer, "xdr:xfrm", attributes, false);

        // a:off
        self.offset.write_to(writer);

        // a:ext
        self.extents.write_to(writer);

        write_end_tag(writer, "xdr:xfrm");
    }
}