diff --git a/phonetic__run_8hpp_source.html b/phonetic__run_8hpp_source.html index b79c8b92..2bdbc8c3 100644 --- a/phonetic__run_8hpp_source.html +++ b/phonetic__run_8hpp_source.html @@ -66,9 +66,9 @@
phonetic_run.hpp
-
1 // Copyright (c) 2016-2020
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE
20 //
21 // @license: http://www.opensource.org/licenses/mit-license.php
22 // @author: see AUTHORS file
23 
24 #pragma once
25 
26 #include <string>
27 
28 #include <xlnt/xlnt_config.hpp>
29 
30 namespace xlnt {
31 
35 struct XLNT_API phonetic_run
36 {
37  std::string text;
38  uint32_t start;
39  uint32_t end;
40  bool preserve_space;
41 
42  bool operator==(const phonetic_run &other) const;
43  bool operator!=(const phonetic_run &other) const;
44 };
45 
46 } // namespace xlnt
xlnt
Enumerates the possible types a cell can be determined by it&#39;s current value.
Definition: cell.hpp:36
+
1 // Copyright (c) 2016-2020
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE
20 //
21 // @license: http://www.opensource.org/licenses/mit-license.php
22 // @author: see AUTHORS file
23 
24 #pragma once
25 
26 #include <stdint.h>
27 #include <string>
28 
29 #include <xlnt/xlnt_config.hpp>
30 
31 namespace xlnt {
32 
36 struct XLNT_API phonetic_run
37 {
38  std::string text;
39  uint32_t start;
40  uint32_t end;
41  bool preserve_space;
42 
43  bool operator==(const phonetic_run &other) const;
44  bool operator!=(const phonetic_run &other) const;
45 };
46 
47 } // namespace xlnt
xlnt
Enumerates the possible types a cell can be determined by it&#39;s current value.
Definition: cell.hpp:36
xlnt::operator==
bool operator==(std::nullptr_t, const cell &cell)
Returns true if this cell is uninitialized.
-
xlnt::phonetic_run
Encapsulates a run of text that
Definition: phonetic_run.hpp:35
+
xlnt::phonetic_run
Encapsulates a run of text that
Definition: phonetic_run.hpp:36
xlnt::operator!=
bool operator!=(const std::string &reference_string, const range_reference &ref)
Returns true if the string representation of the range is not equivalent to ref.
diff --git a/rich__text_8hpp_source.html b/rich__text_8hpp_source.html index ca6bd1c6..4ef7eece 100644 --- a/rich__text_8hpp_source.html +++ b/rich__text_8hpp_source.html @@ -72,7 +72,7 @@
xlnt::font
Describes the font style of a particular cell.
Definition: font.hpp:40
xlnt::operator==
bool operator==(std::nullptr_t, const cell &cell)
Returns true if this cell is uninitialized.
xlnt::rich_text
Encapsulates zero or more formatted text runs where a text run is a string of text with the same defi...
Definition: rich_text.hpp:40
-
xlnt::phonetic_run
Encapsulates a run of text that
Definition: phonetic_run.hpp:35
+
xlnt::phonetic_run
Encapsulates a run of text that
Definition: phonetic_run.hpp:36
xlnt::optional
Many settings in xlnt are allowed to not have a value set. This class encapsulates a value which may ...
Definition: format.hpp:43
xlnt::rich_text_hash
Definition: rich_text.hpp:163
xlnt::operator!=
bool operator!=(const std::string &reference_string, const range_reference &ref)
Returns true if the string representation of the range is not equivalent to ref.
diff --git a/variant_8hpp_source.html b/variant_8hpp_source.html index 0f676321..2f495c0d 100644 --- a/variant_8hpp_source.html +++ b/variant_8hpp_source.html @@ -66,8 +66,8 @@
variant.hpp
-
1 // Copyright (c) 2017-2021 Thomas Fussell
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE
20 //
21 // @license: http://www.opensource.org/licenses/mit-license.php
22 // @author: see AUTHORS file
23 
24 #pragma once
25 
26 #include <string>
27 #include <vector>
28 
29 #include <xlnt/xlnt_config.hpp>
30 
31 namespace xlnt {
32 
33 struct datetime;
34 
38 class XLNT_API variant
39 {
40 public:
41  // TODO: implement remaining types?
42 
46  enum class type
47  {
48  vector,
49  //array,
50  //blob,
51  //oblob,
52  //empty,
53  null,
54  //i1,
55  //i2,
56  i4,
57  //i8,
58  //integer,
59  //ui1,
60  //ui2,
61  //ui4,
62  //ui8,
63  //uint,
64  //r4,
65  //r8,
66  //decimal,
67  lpstr, // TODO: how does this differ from lpwstr?
68  //lpwstr,
69  //bstr,
70  date,
71  //filetime,
72  boolean,
73  //cy,
74  //error,
75  //stream,
76  //ostream,
77  //storage,
78  //ostorage,
79  //vstream,
80  //clsid
81  };
82 
86  variant();
87 
91  variant(const std::string &value);
92 
96  variant(const char *value);
97 
101  variant(std::int32_t value);
102 
106  variant(bool value);
107 
111  variant(const datetime &value);
112 
116  variant(const std::initializer_list<std::int32_t> &value);
117 
121  variant(const std::vector<std::int32_t> &value);
122 
126  variant(const std::initializer_list<const char *> &value);
127 
131  variant(const std::vector<const char *> &value);
132 
136  variant(const std::initializer_list<std::string> &value);
137 
141  variant(const std::vector<std::string> &value);
142 
146  variant(const std::vector<variant> &value);
147 
151  bool is(type t) const;
152 
157  template <typename T>
158  T get() const;
159 
163  type value_type() const;
164 
165  bool operator==(const variant &rhs) const;
166 
167 private:
168  type type_;
169  std::vector<variant> vector_value_;
170  std::int32_t i4_value_;
171  std::string lpstr_value_;
172 };
173 
174 template <>
175 bool variant::get() const;
176 
177 template <>
178 std::int32_t variant::get() const;
179 
180 template <>
181 std::string variant::get() const;
182 
183 template <>
184 datetime variant::get() const;
185 
186 template <>
187 std::vector<std::int32_t> variant::get() const;
188 
189 template <>
190 std::vector<std::string> variant::get() const;
191 
192 template <>
193 std::vector<variant> variant::get() const;
194 
195 } // namespace xlnt
xlnt::variant::type
type
The possible types a variant can hold.
Definition: variant.hpp:46
-
xlnt::variant
Represents an object that can have variable type.
Definition: variant.hpp:38
+
1 // Copyright (c) 2017-2021 Thomas Fussell
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE
20 //
21 // @license: http://www.opensource.org/licenses/mit-license.php
22 // @author: see AUTHORS file
23 
24 #pragma once
25 
26 #include <cstdint>
27 #include <string>
28 #include <vector>
29 
30 #include <xlnt/xlnt_config.hpp>
31 
32 namespace xlnt {
33 
34 struct datetime;
35 
39 class XLNT_API variant
40 {
41 public:
42  // TODO: implement remaining types?
43 
47  enum class type
48  {
49  vector,
50  //array,
51  //blob,
52  //oblob,
53  //empty,
54  null,
55  //i1,
56  //i2,
57  i4,
58  //i8,
59  //integer,
60  //ui1,
61  //ui2,
62  //ui4,
63  //ui8,
64  //uint,
65  //r4,
66  //r8,
67  //decimal,
68  lpstr, // TODO: how does this differ from lpwstr?
69  //lpwstr,
70  //bstr,
71  date,
72  //filetime,
73  boolean,
74  //cy,
75  //error,
76  //stream,
77  //ostream,
78  //storage,
79  //ostorage,
80  //vstream,
81  //clsid
82  };
83 
87  variant();
88 
92  variant(const std::string &value);
93 
97  variant(const char *value);
98 
102  variant(std::int32_t value);
103 
107  variant(bool value);
108 
112  variant(const datetime &value);
113 
117  variant(const std::initializer_list<std::int32_t> &value);
118 
122  variant(const std::vector<std::int32_t> &value);
123 
127  variant(const std::initializer_list<const char *> &value);
128 
132  variant(const std::vector<const char *> &value);
133 
137  variant(const std::initializer_list<std::string> &value);
138 
142  variant(const std::vector<std::string> &value);
143 
147  variant(const std::vector<variant> &value);
148 
152  bool is(type t) const;
153 
158  template <typename T>
159  T get() const;
160 
164  type value_type() const;
165 
166  bool operator==(const variant &rhs) const;
167 
168 private:
169  type type_;
170  std::vector<variant> vector_value_;
171  std::int32_t i4_value_;
172  std::string lpstr_value_;
173 };
174 
175 template <>
176 bool variant::get() const;
177 
178 template <>
179 std::int32_t variant::get() const;
180 
181 template <>
182 std::string variant::get() const;
183 
184 template <>
185 datetime variant::get() const;
186 
187 template <>
188 std::vector<std::int32_t> variant::get() const;
189 
190 template <>
191 std::vector<std::string> variant::get() const;
192 
193 template <>
194 std::vector<variant> variant::get() const;
195 
196 } // namespace xlnt
xlnt::variant::type
type
The possible types a variant can hold.
Definition: variant.hpp:47
+
xlnt::variant
Represents an object that can have variable type.
Definition: variant.hpp:39
xlnt::variant::get
T get() const
Returns the value of this variant as type T. An exception will be thrown if the types are not convert...
xlnt
Enumerates the possible types a cell can be determined by it&#39;s current value.
Definition: cell.hpp:36
xlnt::operator==
bool operator==(std::nullptr_t, const cell &cell)
Returns true if this cell is uninitialized.
diff --git a/workbook_8hpp_source.html b/workbook_8hpp_source.html index 3ec6d24e..99e7e3b5 100644 --- a/workbook_8hpp_source.html +++ b/workbook_8hpp_source.html @@ -69,7 +69,7 @@
1 // Copyright (c) 2014-2021 Thomas Fussell
2 // Copyright (c) 2010-2015 openpyxl
3 //
4 // Permission is hereby granted, free of charge, to any person obtaining a copy
5 // of this software and associated documentation files (the "Software"), to deal
6 // in the Software without restriction, including without limitation the rights
7 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 // copies of the Software, and to permit persons to whom the Software is
9 // furnished to do so, subject to the following conditions:
10 //
11 // The above copyright notice and this permission notice shall be included in
12 // all copies or substantial portions of the Software.
13 //
14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 // THE SOFTWARE
21 //
22 // @license: http://www.opensource.org/licenses/mit-license.php
23 // @author: see AUTHORS file
24 
25 #pragma once
26 
27 #include <functional>
28 #include <iterator>
29 #include <map>
30 #include <memory>
31 #include <string>
32 #include <unordered_map>
33 #include <utility>
34 #include <vector>
35 
36 #include <xlnt/xlnt_config.hpp>
37 #include <xlnt/cell/rich_text.hpp>
38 
39 namespace xlnt {
40 
41 enum class calendar;
42 enum class core_property;
43 enum class extended_property;
44 enum class relationship_type;
45 
46 class alignment;
47 class border;
48 class calculation_properties;
49 class cell;
50 class cell_style;
51 class color;
52 class const_worksheet_iterator;
53 class fill;
54 class font;
55 class format;
56 class rich_text;
57 class manifest;
58 class metadata_property;
59 class named_range;
60 class number_format;
61 class path;
62 class pattern_fill;
63 class protection;
64 class range;
65 class range_reference;
66 class relationship;
67 class streaming_workbook_reader;
68 class style;
69 class style_serializer;
70 class theme;
71 class variant;
72 class workbook_view;
73 class worksheet;
74 class worksheet_iterator;
75 class zip_file;
76 
77 struct datetime;
78 
79 namespace detail {
80 
81 struct stylesheet;
82 struct workbook_impl;
83 class xlsx_consumer;
84 class xlsx_producer;
85 
86 } // namespace detail
87 
91 class XLNT_API workbook
92 {
93 public:
98  using iterator = worksheet_iterator;
99 
104  using const_iterator = const_worksheet_iterator;
105 
111  using reverse_iterator = std::reverse_iterator<iterator>;
112 
118  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
119 
124  static workbook empty();
125 
126  // Constructors
127 
132  workbook();
133 
137  workbook(const xlnt::path &file);
138 
142  workbook(const xlnt::path &file, const std::string &password);
143 
147  workbook(std::istream &data);
148 
152  workbook(std::istream &data, const std::string &password);
153 
157  workbook(workbook &&other);
158 
162  workbook(const workbook &other);
163 
169  ~workbook();
170 
171  // Worksheets
172 
176  worksheet create_sheet();
177 
181  worksheet create_sheet(std::size_t index);
182 
186  worksheet create_sheet_with_rel(const std::string &title, const relationship &rel);
187 
192  worksheet copy_sheet(worksheet worksheet);
193 
198  worksheet copy_sheet(worksheet worksheet, std::size_t index);
199 
204  worksheet active_sheet();
205 
210  void active_sheet(std::size_t index);
211 
217  worksheet sheet_by_title(const std::string &title);
218 
224  const worksheet sheet_by_title(const std::string &title) const;
225 
230  worksheet sheet_by_index(std::size_t index);
231 
236  const worksheet sheet_by_index(std::size_t index) const;
237 
242  worksheet sheet_by_id(std::size_t id);
243 
248  const worksheet sheet_by_id(std::size_t id) const;
249 
255  bool sheet_hidden_by_index(std::size_t index) const;
256 
260  bool contains(const std::string &title) const;
261 
265  std::size_t index(worksheet worksheet);
266 
267  // remove worksheets
268 
272  void remove_sheet(worksheet worksheet);
273 
278  void clear();
279 
280  // iterators
281 
285  iterator begin();
286 
292  iterator end();
293 
297  const_iterator begin() const;
298 
304  const_iterator end() const;
305 
309  const_iterator cbegin() const;
310 
316  const_iterator cend() const;
317 
321  void apply_to_cells(std::function<void(cell)> f);
322 
327  std::vector<std::string> sheet_titles() const;
328 
332  std::size_t sheet_count() const;
333 
334  // Metadata Properties
335 
339  bool has_core_property(xlnt::core_property type) const;
340 
345  std::vector<xlnt::core_property> core_properties() const;
346 
350  variant core_property(xlnt::core_property type) const;
351 
355  void core_property(xlnt::core_property type, const variant &value);
356 
360  bool has_extended_property(xlnt::extended_property type) const;
361 
366  std::vector<xlnt::extended_property> extended_properties() const;
367 
371  variant extended_property(xlnt::extended_property type) const;
372 
376  void extended_property(xlnt::extended_property type, const variant &value);
377 
381  bool has_custom_property(const std::string &property_name) const;
382 
387  std::vector<std::string> custom_properties() const;
388 
392  variant custom_property(const std::string &property_name) const;
393 
397  void custom_property(const std::string &property_name, const variant &value);
398 
404  calendar base_date() const;
405 
410  void base_date(calendar base_date);
411 
415  bool has_title() const;
416 
420  std::string title() const;
421 
425  void title(const std::string &title);
426 
430  void abs_path(const std::string &path);
431 
435  void arch_id_flags(const std::size_t flags);
436 
437  // Named Ranges
438 
442  std::vector<xlnt::named_range> named_ranges() const;
443 
447  void create_named_range(const std::string &name, worksheet worksheet, const range_reference &reference);
448 
452  void create_named_range(const std::string &name, worksheet worksheet, const std::string &reference_string);
453 
457  bool has_named_range(const std::string &name) const;
458 
462  class range named_range(const std::string &name);
463 
467  void remove_named_range(const std::string &name);
468 
469  // Serialization/Deserialization
470 
475  void save(std::vector<std::uint8_t> &data) const;
476 
481  void save(std::vector<std::uint8_t> &data, const std::string &password) const;
482 
487  void save(const std::string &filename) const;
488 
493  void save(const std::string &filename, const std::string &password) const;
494 
495 #ifdef _MSC_VER
496  void save(const std::wstring &filename) const;
501 
506  void save(const std::wstring &filename, const std::string &password) const;
507 #endif
508 
513  void save(const xlnt::path &filename) const;
514 
519  void save(const xlnt::path &filename, const std::string &password) const;
520 
524  void save(std::ostream &stream) const;
525 
530  void save(std::ostream &stream, const std::string &password) const;
531 
536  void load(const std::vector<std::uint8_t> &data);
537 
542  void load(const std::vector<std::uint8_t> &data, const std::string &password);
543 
548  void load(const std::string &filename);
549 
554  void load(const std::string &filename, const std::string &password);
555 
556 #ifdef _MSC_VER
557  void load(const std::wstring &filename);
562 
567  void load(const std::wstring &filename, const std::string &password);
568 #endif
569 
574  void load(const xlnt::path &filename);
575 
580  void load(const xlnt::path &filename, const std::string &password);
581 
586  void load(std::istream &stream);
587 
592  void load(std::istream &stream, const std::string &password);
593 
594  // View
595 
599  bool has_view() const;
600 
604  workbook_view view() const;
605 
609  void view(const workbook_view &view);
610 
611  // Properties
612 
616  bool has_code_name() const;
617 
621  std::string code_name() const;
622 
626  void code_name(const std::string &code_name);
627 
631  bool has_file_version() const;
632 
636  std::string app_name() const;
637 
641  std::size_t last_edited() const;
642 
646  std::size_t lowest_edited() const;
647 
651  std::size_t rup_build() const;
652 
653  // Theme
654 
658  bool has_theme() const;
659 
663  const xlnt::theme &theme() const;
664 
668  void theme(const class theme &value);
669 
670  // Formats
671 
676  xlnt::format format(std::size_t format_index);
677 
682  const xlnt::format format(std::size_t format_index) const;
683 
687  xlnt::format create_format(bool default_format = false);
688 
693  void clear_formats();
694 
695  // Styles
696 
700  bool has_style(const std::string &name) const;
701 
705  class style style(const std::string &name);
706 
710  const class style style(const std::string &name) const;
711 
715  class style create_style(const std::string &name);
716 
720  class style create_builtin_style(std::size_t builtin_id);
721 
727  void clear_styles();
728 
732  void default_slicer_style(const std::string &value);
733 
737  std::string default_slicer_style() const;
738 
742  void enable_known_fonts();
743 
747  void disable_known_fonts();
748 
752  bool known_fonts_enabled() const;
753 
754  // Manifest
755 
759  class manifest &manifest();
760 
764  const class manifest &manifest() const;
765 
766  // shared strings
767 
774  std::size_t add_shared_string(const rich_text &shared, bool allow_duplicates = false);
775 
779  const rich_text &shared_strings(std::size_t index) const;
780 
785  std::vector<rich_text> &shared_strings();
786 
791  const std::vector<rich_text> &shared_strings() const;
792 
793  // Thumbnail
794 
799  void thumbnail(const std::vector<std::uint8_t> &thumbnail,
800  const std::string &extension, const std::string &content_type);
801 
805  const std::vector<std::uint8_t> &thumbnail() const;
806 
810  const std::unordered_map<std::string, std::vector<std::uint8_t>>& binaries() const;
811 
812  // Calculation properties
813 
817  bool has_calculation_properties() const;
818 
822  class calculation_properties calculation_properties() const;
823 
827  void calculation_properties(const class calculation_properties &props);
828 
829  // Operators
830 
835  workbook &operator=(workbook other);
836 
840  worksheet operator[](const std::string &name);
841 
845  worksheet operator[](std::size_t index);
846 
851  bool operator==(const workbook &rhs) const;
852 
857  bool operator!=(const workbook &rhs) const;
858 
859 private:
860  friend class streaming_workbook_reader;
861  friend class worksheet;
862  friend class detail::xlsx_consumer;
863  friend class detail::xlsx_producer;
864 
869  workbook(detail::workbook_impl *impl);
870 
875  detail::workbook_impl &impl();
876 
881  const detail::workbook_impl &impl() const;
882 
888  void register_package_part(relationship_type type);
889 
896  void register_workbook_part(relationship_type type);
897 
904  void register_worksheet_part(worksheet ws, relationship_type type);
905 
909  void garbage_collect_formulae();
910 
914  void update_sheet_properties();
915 
919  void swap(workbook &other);
920 
924  void reorder_relationships();
925 
929  std::unique_ptr<detail::workbook_impl> d_;
930 };
931 
932 } // namespace xlnt
xlnt::core_property
core_property
Every core property in a workbook must be one of these types.
Definition: metadata_property.hpp:33
xlnt::range
A range is a 2D collection of cells with defined extens that can be iterated upon.
Definition: range.hpp:54
xlnt::relationship
Represents an association between a source Package or part, and a target object which can be a part o...
Definition: relationship.hpp:102
-
xlnt::variant
Represents an object that can have variable type.
Definition: variant.hpp:38
+
xlnt::variant
Represents an object that can have variable type.
Definition: variant.hpp:39
std
Definition: cell_reference.hpp:261
xlnt::workbook_view
A workbook can be opened in multiple windows with different views. This class represents a particular...
Definition: workbook_view.hpp:36
xlnt
Enumerates the possible types a cell can be determined by it&#39;s current value.
Definition: cell.hpp:36