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

use super::EffectList;
use super::Scene3DType;
use super::Shape3DType;
use crate::reader::driver::*;
use crate::writer::driver::*;
use quick_xml::events::{BytesStart, Event};
use quick_xml::Reader;
use quick_xml::Writer;
use std::io::Cursor;
use std::vec;

#[derive(Clone, Default, Debug)]
pub struct EffectStyle {
    effect_list: Option<Box<EffectList>>,
    scene_3d_type: Option<Box<Scene3DType>>,
    shape_3d_type: Option<Box<Shape3DType>>,
}

impl EffectStyle {
    #[inline]
    pub fn get_effect_list(&self) -> Option<&EffectList> {
        self.effect_list.as_deref()
    }

    #[inline]
    pub fn get_effect_list_mut(&mut self) -> Option<&mut EffectList> {
        self.effect_list.as_deref_mut()
    }

    #[inline]
    pub fn set_effect_list(&mut self, value: EffectList) -> &mut Self {
        self.effect_list = Some(Box::new(value));
        self
    }

    #[inline]
    pub fn get_scene_3d_type(&self) -> Option<&Scene3DType> {
        self.scene_3d_type.as_deref()
    }

    #[inline]
    pub fn get_scene_3d_type_mut(&mut self) -> Option<&mut Scene3DType> {
        self.scene_3d_type.as_deref_mut()
    }

    #[inline]
    pub fn set_scene_3d_type(&mut self, value: Scene3DType) -> &mut Self {
        self.scene_3d_type = Some(Box::new(value));
        self
    }

    #[inline]
    pub fn get_shape_3d_type(&self) -> Option<&Shape3DType> {
        self.shape_3d_type.as_deref()
    }

    #[inline]
    pub fn get_shape_3d_type_mut(&mut self) -> Option<&mut Shape3DType> {
        self.shape_3d_type.as_deref_mut()
    }

    #[inline]
    pub fn set_shape_3d_type(&mut self, value: Shape3DType) -> &mut Self {
        self.shape_3d_type = Some(Box::new(value));
        self
    }

    pub(crate) fn set_attributes<R: std::io::BufRead>(
        &mut self,
        reader: &mut Reader<R>,
        _e: &BytesStart,
    ) {
        xml_read_loop!(
            reader,
            Event::Start(ref e) => {
                match e.name().into_inner() {
                b"a:effectLst" => {
                    let mut obj = EffectList::default();
                    obj.set_attributes(reader, e, false);
                    self.effect_list = Some(Box::new(obj));
                }
                b"a:scene3d" => {
                    let mut obj = Scene3DType::default();
                    obj.set_attributes(reader, e);
                    self.scene_3d_type = Some(Box::new(obj));
                }
                b"a:sp3d" => {
                    let mut obj = Shape3DType::default();
                    obj.set_attributes(reader, e);
                    self.shape_3d_type = Some(Box::new(obj));
                }
                _ => (),
                }
            },
            Event::Empty(ref e) => {
                if e.name().into_inner() == b"a:effectLst" {
                    let mut obj = EffectList::default();
                    obj.set_attributes(reader, e, true);
                    self.set_effect_list(obj);
                }
            },
            Event::End(ref e) => {
                if e.name().into_inner() == b"a:effectStyle" {
                    return
                }
            },
            Event::Eof => panic!("Error: Could not find {} end element", "a:effectStyle")
        );
    }

    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
        write_start_tag(writer, "a:effectStyle", vec![], false);

        // a:effectLst
        if let Some(v) = &self.effect_list {
            v.write_to(writer);
        }

        // a:scene3d
        if let Some(v) = &self.scene_3d_type {
            v.write_to(writer);
        }

        // a:sp3d
        if let Some(v) = &self.shape_3d_type {
            v.write_to(writer);
        }

        write_end_tag(writer, "a:effectStyle");
    }
}