xlnt/docs/source/includes/_api_reference.md
2017-04-11 17:27:41 -04:00

2429 lines
159 KiB
Markdown

# API Reference
## Cell Module
### cell
#### ```using xlnt::cell::type = cell_typeundefined```
Alias xlnt::cell_type to xlnt::cell::type since it looks nicer.
#### ```friend class detail::xlsx_consumerundefined```
#### ```friend class detail::xlsx_producerundefined```
#### ```friend struct detail::cell_implundefined```
#### ```static const std::unordered_map<std::string, int>& xlnt::cell::error_codes()```
Returns a map of error strings such as #DIV/0! and their associated indices.
#### ```xlnt::cell::cell(const cell &)=default```
Default copy constructor.
#### ```bool xlnt::cell::has_value() const```
Returns true if value has been set and has not been cleared using cell::clear_value().
#### ```T xlnt::cell::value() const```
Returns the value of this cell as an instance of type T. Overloads exist for most C++ fundamental types like bool, int, etc. as well as for std::string and xlnt datetime types: date, time, datetime, and timedelta.
#### ```void xlnt::cell::clear_value()```
Makes this cell have a value of type null. All other cell attributes are retained.
#### ```void xlnt::cell::value(std::nullptr_t)```
Sets the type of this cell to null.
#### ```void xlnt::cell::value(bool boolean_value)```
Sets the value of this cell to the given boolean value.
#### ```void xlnt::cell::value(int int_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(unsigned int int_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(long long int int_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(unsigned long long int int_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(float float_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(double float_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(long double float_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const date &date_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const time &time_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const datetime &datetime_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const timedelta &timedelta_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const std::string &string_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const char *string_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const rich_text &text_value)```
Sets the value of this cell to the given value.
#### ```void xlnt::cell::value(const cell other_cell)```
Sets the value and formatting of this cell to that of other_cell.
#### ```void xlnt::cell::value(const std::string &string_value, bool infer_type)```
Analyzes string_value to determine its type, convert it to that type, and set the value of this cell to that converted value.
#### ```type xlnt::cell::data_type() const```
Returns the type of this cell.
#### ```void xlnt::cell::data_type(type t)```
Sets the type of this cell. This should usually be done indirectly by setting the value of the cell to a value of that type.
#### ```bool xlnt::cell::garbage_collectible() const```
There's no reason to keep a cell which has no value and is not a placeholder. Returns true if this cell has no value, style, isn't merged, etc.
#### ```bool xlnt::cell::is_date() const```
Returns true iff this cell's number format matches a date format.
#### ```cell_reference xlnt::cell::reference() const```
Returns a cell_reference that points to the location of this cell.
#### ```column_t xlnt::cell::column() const```
Returns the column of this cell.
#### ```row_t xlnt::cell::row() const```
Returns the row of this cell.
#### ```std::pair<int, int> xlnt::cell::anchor() const```
Returns the location of this cell as an ordered pair (left, top).
#### ```std::string xlnt::cell::hyperlink() const```
Returns the URL of this cell's hyperlink.
#### ```void xlnt::cell::hyperlink(const std::string &url)```
Adds a hyperlink to this cell pointing to the URL of the given value.
#### ```void xlnt::cell::hyperlink(const std::string &url, const std::string &display)```
Adds a hyperlink to this cell pointing to the URI of the given value and sets the text value of the cell to the given parameter.
#### ```void xlnt::cell::hyperlink(xlnt::cell target)```
Adds an internal hyperlink to this cell pointing to the given cell.
#### ```bool xlnt::cell::has_hyperlink() const```
Returns true if this cell has a hyperlink set.
#### ```class alignment xlnt::cell::computed_alignment() const```
Returns the alignment that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order.
#### ```class border xlnt::cell::computed_border() const```
Returns the border that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order.
#### ```class fill xlnt::cell::computed_fill() const```
Returns the fill that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order.
#### ```class font xlnt::cell::computed_font() const```
Returns the font that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order.
#### ```class number_format xlnt::cell::computed_number_format() const```
Returns the number format that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order.
#### ```class protection xlnt::cell::computed_protection() const```
Returns the protection that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order.
#### ```bool xlnt::cell::has_format() const```
Returns true if this cell has had a format applied to it.
#### ```const class format xlnt::cell::format() const```
Returns the format applied to this cell. If this cell has no format, an invalid_attribute exception will be thrown.
#### ```void xlnt::cell::format(const class format new_format)```
Applies the cell-level formatting of new_format to this cell.
#### ```void xlnt::cell::clear_format()```
Removes the cell-level formatting from this cell. This doesn't affect the style that may also be applied to the cell. Throws an invalid_attribute exception if no format is applied.
#### ```class number_format xlnt::cell::number_format() const```
Returns the number format of this cell.
#### ```void xlnt::cell::number_format(const class number_format &format)```
Creates a new format in the workbook, sets its number_format to the given format, and applies the format to this cell.
#### ```class font xlnt::cell::font() const```
Returns the font applied to the text in this cell.
#### ```void xlnt::cell::font(const class font &font_)```
Creates a new format in the workbook, sets its font to the given font, and applies the format to this cell.
#### ```class fill xlnt::cell::fill() const```
Returns the fill applied to this cell.
#### ```void xlnt::cell::fill(const class fill &fill_)```
Creates a new format in the workbook, sets its fill to the given fill, and applies the format to this cell.
#### ```class border xlnt::cell::border() const```
Returns the border of this cell.
#### ```void xlnt::cell::border(const class border &border_)```
Creates a new format in the workbook, sets its border to the given border, and applies the format to this cell.
#### ```class alignment xlnt::cell::alignment() const```
Returns the alignment of the text in this cell.
#### ```void xlnt::cell::alignment(const class alignment &alignment_)```
Creates a new format in the workbook, sets its alignment to the given alignment, and applies the format to this cell.
#### ```class protection xlnt::cell::protection() const```
Returns the protection of this cell.
#### ```void xlnt::cell::protection(const class protection &protection_)```
Creates a new format in the workbook, sets its protection to the given protection, and applies the format to this cell.
#### ```bool xlnt::cell::has_style() const```
Returns true if this cell has had a style applied to it.
#### ```class style xlnt::cell::style()```
Returns a wrapper pointing to the named style applied to this cell.
#### ```const class style xlnt::cell::style() const```
Returns a wrapper pointing to the named style applied to this cell.
#### ```void xlnt::cell::style(const class style &new_style)```
Sets the named style applied to this cell to a style named style_name. Equivalent to style(new_style.name()).
#### ```void xlnt::cell::style(const std::string &style_name)```
Sets the named style applied to this cell to a style named style_name. If this style has not been previously created in the workbook, a key_not_found exception will be thrown.
#### ```void xlnt::cell::clear_style()```
Removes the named style from this cell. An invalid_attribute exception will be thrown if this cell has no style. This will not affect the cell format of the cell.
#### ```std::string xlnt::cell::formula() const```
Returns the string representation of the formula applied to this cell.
#### ```void xlnt::cell::formula(const std::string &formula)```
Sets the formula of this cell to the given value. This formula string should begin with '='.
#### ```void xlnt::cell::clear_formula()```
Removes the formula from this cell. After this is called, has_formula() will return false.
#### ```bool xlnt::cell::has_formula() const```
Returns true if this cell has had a formula applied to it.
#### ```std::string xlnt::cell::to_string() const```
Returns a string representing the value of this cell. If the data type is not a string, it will be converted according to the number format.
#### ```bool xlnt::cell::is_merged() const```
Returns true iff this cell has been merged with one or more surrounding cells.
#### ```void xlnt::cell::merged(bool merged)```
Makes this a merged cell iff merged is true. Generally, this shouldn't be called directly. Instead, use worksheet::merge_cells on its parent worksheet.
#### ```std::string xlnt::cell::error() const```
Returns the error string that is stored in this cell.
#### ```void xlnt::cell::error(const std::string &error)```
Directly assigns the value of this cell to be the given error.
#### ```cell xlnt::cell::offset(int column, int row)```
Returns a cell from this cell's parent workbook at a relative offset given by the parameters.
#### ```class worksheet xlnt::cell::worksheet()```
Returns the worksheet that owns this cell.
#### ```const class worksheet xlnt::cell::worksheet() const```
Returns the worksheet that owns this cell.
#### ```class workbook& xlnt::cell::workbook()```
Returns the workbook of the worksheet that owns this cell.
#### ```const class workbook& xlnt::cell::workbook() const```
Returns the workbook of the worksheet that owns this cell.
#### ```calendar xlnt::cell::base_date() const```
Returns the base date of the parent workbook.
#### ```std::string xlnt::cell::check_string(const std::string &to_check)```
Returns to_check after verifying and fixing encoding, size, and illegal characters.
#### ```bool xlnt::cell::has_comment()```
Returns true if this cell has a comment applied.
#### ```void xlnt::cell::clear_comment()```
Deletes the comment applied to this cell if it exists.
#### ```class comment xlnt::cell::comment()```
Gets the comment applied to this cell.
#### ```void xlnt::cell::comment(const std::string &text, const std::string &author="Microsoft Office User")```
Creates a new comment with the given text and optional author and applies it to the cell.
#### ```void xlnt::cell::comment(const std::string &comment_text, const class font &comment_font, const std::string &author="Microsoft Office User")```
Creates a new comment with the given text, formatting, and optional author and applies it to the cell.
#### ```void xlnt::cell::comment(const class comment &new_comment)```
Apply the comment provided as the only argument to the cell.
#### ```double xlnt::cell::width() const```
Returns the width of this cell in pixels.
#### ```double xlnt::cell::height() const```
Returns the height of this cell in pixels.
#### ```cell& xlnt::cell::operator=(const cell &rhs)```
Makes this cell interally point to rhs. The cell data originally pointed to by this cell will be unchanged.
#### ```bool xlnt::cell::operator==(const cell &comparand) const```
Returns true if this cell the same cell as comparand (compared by reference).
#### ```bool xlnt::cell::operator==(std::nullptr_t) const```
Returns true if this cell is uninitialized.
### cell_reference_hash
#### ```std::size_t xlnt::cell_reference_hash::operator()(const cell_reference &k) const```
Returns a hash representing a particular cell_reference.
### cell_reference
#### ```static std::pair<std::string, row_t> xlnt::cell_reference::split_reference(const std::string &reference_string)```
Splits a coordinate string like "A1" into an equivalent pair like {"A", 1}.
#### ```static std::pair<std::string, row_t> xlnt::cell_reference::split_reference(const std::string &reference_string, bool &absolute_column, bool &absolute_row)```
Splits a coordinate string like "A1" into an equivalent pair like {"A", 1}. Reference parameters absolute_column and absolute_row will be set to true if column part or row part are prefixed by a dollar-sign indicating they are absolute, otherwise false.
#### ```xlnt::cell_reference::cell_reference()```
Default constructor makes a reference to the top-left-most cell, "A1".
#### ```xlnt::cell_reference::cell_reference(const char *reference_string)```
Constructs a cell_reference from a string reprenting a cell coordinate (e.g. $B14).
#### ```xlnt::cell_reference::cell_reference(const std::string &reference_string)```
Constructs a cell_reference from a string reprenting a cell coordinate (e.g. $B14).
#### ```xlnt::cell_reference::cell_reference(column_t column, row_t row)```
Constructs a cell_reference from a 1-indexed column index and row index.
#### ```cell_reference& xlnt::cell_reference::make_absolute(bool absolute_column=true, bool absolute_row=true)```
Converts a coordinate to an absolute coordinate string (e.g. B12 -> $B$12) Defaulting to true, absolute_column and absolute_row can optionally control whether the resulting cell_reference has an absolute column (e.g. B12 -> $B12) and absolute row (e.g. B12 -> B$12) respectively.
#### ```bool xlnt::cell_reference::column_absolute() const```
Returns true if the reference refers to an absolute column, otherwise false.
#### ```void xlnt::cell_reference::column_absolute(bool absolute_column)```
Makes this reference have an absolute column if absolute_column is true, otherwise not absolute.
#### ```bool xlnt::cell_reference::row_absolute() const```
Returns true if the reference refers to an absolute row, otherwise false.
#### ```void xlnt::cell_reference::row_absolute(bool absolute_row)```
Makes this reference have an absolute row if absolute_row is true, otherwise not absolute.
#### ```column_t xlnt::cell_reference::column() const```
Returns a string that identifies the column of this reference (e.g. second column from left is "B")
#### ```void xlnt::cell_reference::column(const std::string &column_string)```
Sets the column of this reference from a string that identifies a particular column.
#### ```column_t::index_t xlnt::cell_reference::column_index() const```
Returns a 1-indexed numeric index of the column of this reference.
#### ```void xlnt::cell_reference::column_index(column_t column)```
Sets the column of this reference from a 1-indexed number that identifies a particular column.
#### ```row_t xlnt::cell_reference::row() const```
Returns a 1-indexed numeric index of the row of this reference.
#### ```void xlnt::cell_reference::row(row_t row)```
Sets the row of this reference from a 1-indexed number that identifies a particular row.
#### ```cell_reference xlnt::cell_reference::make_offset(int column_offset, int row_offset) const```
Returns a cell_reference offset from this cell_reference by the number of columns and rows specified by the parameters. A negative value for column_offset or row_offset results in a reference above or left of this cell_reference, respectively.
#### ```std::string xlnt::cell_reference::to_string() const```
Returns a string like "A1" for cell_reference(1, 1).
#### ```range_reference xlnt::cell_reference::to_range() const```
Returns a 1x1 range_reference containing only this cell_reference.
#### ```range_reference xlnt::cell_reference::operator,(const cell_reference &other) const```
I've always wanted to overload the comma operator. cell_reference("A", 1), cell_reference("B", 1) will return range_reference(cell_reference("A", 1), cell_reference("B", 1))
#### ```bool xlnt::cell_reference::operator==(const cell_reference &comparand) const```
Returns true if this reference is identical to comparand including in absoluteness of column and row.
#### ```bool xlnt::cell_reference::operator==(const std::string &reference_string) const```
Constructs a cell_reference from reference_string and return the result of their comparison.
#### ```bool xlnt::cell_reference::operator==(const char *reference_string) const```
Constructs a cell_reference from reference_string and return the result of their comparison.
#### ```bool xlnt::cell_reference::operator!=(const cell_reference &comparand) const```
Returns true if this reference is not identical to comparand including in absoluteness of column and row.
#### ```bool xlnt::cell_reference::operator!=(const std::string &reference_string) const```
Constructs a cell_reference from reference_string and return the result of their comparison.
#### ```bool xlnt::cell_reference::operator!=(const char *reference_string) const```
Constructs a cell_reference from reference_string and return the result of their comparison.
### comment
#### ```xlnt::comment::comment()```
Constructs a new blank comment.
#### ```xlnt::comment::comment(const rich_text &text, const std::string &author)```
Constructs a new comment with the given text and author.
#### ```xlnt::comment::comment(const std::string &text, const std::string &author)```
Constructs a new comment with the given unformatted text and author.
#### ```rich_text xlnt::comment::text() const```
Returns the text that will be displayed for this comment.
#### ```std::string xlnt::comment::plain_text() const```
Returns the plain text that will be displayed for this comment without formatting information.
#### ```std::string xlnt::comment::author() const```
Returns the author of this comment.
#### ```void xlnt::comment::hide()```
Makes this comment only visible when the associated cell is hovered.
#### ```void xlnt::comment::show()```
Makes this comment always visible.
#### ```bool xlnt::comment::visible() const```
Returns true if this comment is not hidden.
#### ```void xlnt::comment::position(int left, int top)```
Sets the absolute position of this cell to the given coordinates.
#### ```int xlnt::comment::left() const```
Returns the distance from the left side of the sheet to the left side of the comment.
#### ```int xlnt::comment::top() const```
Returns the distance from the top of the sheet to the top of the comment.
#### ```void xlnt::comment::size(int width, int height)```
Sets the size of the comment.
#### ```int xlnt::comment::width() const```
Returns the width of this comment.
#### ```int xlnt::comment::height() const```
Returns the height of this comment.
#### ```bool xlnt::comment::operator==(const comment &other) const```
Return true if this comment is equivalent to other.
#### ```bool xlnt::comment::operator!=(const comment &other) const```
Returns true if this comment is not equivalent to other.
### column_t
#### ```using xlnt::column_t::index_t = std::uint32_tundefined```
Alias declaration for the internal numeric type of this column.
#### ```index_t xlnt::column_t::indexundefined```
Internal numeric value of this column index.
#### ```static index_t xlnt::column_t::column_index_from_string(const std::string &column_string)```
Convert a column letter into a column number (e.g. B -> 2)
#### ```static std::string xlnt::column_t::column_string_from_index(index_t column_index)```
Convert a column number into a column letter (3 -> 'C')
#### ```xlnt::column_t::column_t()```
Default constructor. The column points to the "A" column.
#### ```xlnt::column_t::column_t(index_t column_index)```
Constructs a column from a number.
#### ```xlnt::column_t::column_t(const std::string &column_string)```
Constructs a column from a string.
#### ```xlnt::column_t::column_t(const char *column_string)```
Constructs a column from a string.
#### ```xlnt::column_t::column_t(const column_t &other)```
Copy constructor. Constructs a column by copying it from other.
#### ```xlnt::column_t::column_t(column_t &&other)```
Move constructor. Constructs a column by moving it from other.
#### ```std::string xlnt::column_t::column_string() const```
Returns a string representation of this column index.
#### ```column_t& xlnt::column_t::operator=(column_t rhs)```
Sets this column to be the same as rhs's and return reference to self.
#### ```column_t& xlnt::column_t::operator=(const std::string &rhs)```
Sets this column to be equal to rhs and return reference to self.
#### ```column_t& xlnt::column_t::operator=(const char *rhs)```
Sets this column to be equal to rhs and return reference to self.
#### ```bool xlnt::column_t::operator==(const column_t &other) const```
Returns true if this column refers to the same column as other.
#### ```bool xlnt::column_t::operator!=(const column_t &other) const```
Returns true if this column doesn't refer to the same column as other.
#### ```bool xlnt::column_t::operator==(int other) const```
Returns true if this column refers to the same column as other.
#### ```bool xlnt::column_t::operator==(index_t other) const```
Returns true if this column refers to the same column as other.
#### ```bool xlnt::column_t::operator==(const std::string &other) const```
Returns true if this column refers to the same column as other.
#### ```bool xlnt::column_t::operator==(const char *other) const```
Returns true if this column refers to the same column as other.
#### ```bool xlnt::column_t::operator!=(int other) const```
Returns true if this column doesn't refer to the same column as other.
#### ```bool xlnt::column_t::operator!=(index_t other) const```
Returns true if this column doesn't refer to the same column as other.
#### ```bool xlnt::column_t::operator!=(const std::string &other) const```
Returns true if this column doesn't refer to the same column as other.
#### ```bool xlnt::column_t::operator!=(const char *other) const```
Returns true if this column doesn't refer to the same column as other.
#### ```bool xlnt::column_t::operator>(const column_t &other) const```
Returns true if other is to the right of this column.
#### ```bool xlnt::column_t::operator>=(const column_t &other) const```
Returns true if other is to the right of or equal to this column.
#### ```bool xlnt::column_t::operator<(const column_t &other) const```
Returns true if other is to the left of this column.
#### ```bool xlnt::column_t::operator<=(const column_t &other) const```
Returns true if other is to the left of or equal to this column.
#### ```bool xlnt::column_t::operator>(const column_t::index_t &other) const```
Returns true if other is to the right of this column.
#### ```bool xlnt::column_t::operator>=(const column_t::index_t &other) const```
Returns true if other is to the right of or equal to this column.
#### ```bool xlnt::column_t::operator<(const column_t::index_t &other) const```
Returns true if other is to the left of this column.
#### ```bool xlnt::column_t::operator<=(const column_t::index_t &other) const```
Returns true if other is to the left of or equal to this column.
#### ```column_t& xlnt::column_t::operator++()```
Pre-increments this column, making it point to the column one to the right and returning a reference to it.
#### ```column_t& xlnt::column_t::operator--()```
Pre-deccrements this column, making it point to the column one to the left and returning a reference to it.
#### ```column_t xlnt::column_t::operator++(int)```
Post-increments this column, making it point to the column one to the right and returning the old column.
#### ```column_t xlnt::column_t::operator--(int)```
Post-decrements this column, making it point to the column one to the left and returning the old column.
#### ```column_t& xlnt::column_t::operator+=(const column_t &rhs)```
Adds rhs to this column and returns a reference to this column.
#### ```column_t& xlnt::column_t::operator-=(const column_t &rhs)```
Subtracts rhs from this column and returns a reference to this column.
#### ```column_t operator+(column_t lhs, const column_t &rhs)```
Returns the result of adding rhs to this column.
#### ```column_t operator-(column_t lhs, const column_t &rhs)```
Returns the result of subtracing lhs by rhs column.
#### ```bool operator>(const column_t::index_t &left, const column_t &right)```
Returns true if other is to the right of this column.
#### ```bool operator>=(const column_t::index_t &left, const column_t &right)```
Returns true if other is to the right of or equal to this column.
#### ```bool operator<(const column_t::index_t &left, const column_t &right)```
Returns true if other is to the left of this column.
#### ```bool operator<=(const column_t::index_t &left, const column_t &right)```
Returns true if other is to the left of or equal to this column.
#### ```void swap(column_t &left, column_t &right)```
Swaps the columns that left and right refer to.
### column_hash
#### ```std::size_t xlnt::column_hash::operator()(const column_t &k) const```
Returns the result of hashing column k.
### column_t >
#### ```size_t std::hash< xlnt::column_t >::operator()(const xlnt::column_t &k) const```
Returns the result of hashing column k.
### rich_text
#### ```xlnt::rich_text::rich_text()=default```
Constructs an empty rich text object with no font and empty text.
#### ```xlnt::rich_text::rich_text(const std::string &plain_text)```
Constructs a rich text object with the given text and no font.
#### ```xlnt::rich_text::rich_text(const std::string &plain_text, const class font &text_font)```
Constructs a rich text object with the given text and font.
#### ```xlnt::rich_text::rich_text(const rich_text_run &single_run)```
Copy constructor.
#### ```void xlnt::rich_text::clear()```
Removes all text runs from this text.
#### ```void xlnt::rich_text::plain_text(const std::string &s)```
Clears any runs in this text and adds a single run with default formatting and the given string as its textual content.
#### ```std::string xlnt::rich_text::plain_text() const```
Combines the textual content of each text run in order and returns the result.
#### ```std::vector<rich_text_run> xlnt::rich_text::runs() const```
Returns a copy of the individual runs that comprise this text.
#### ```void xlnt::rich_text::runs(const std::vector< rich_text_run > &new_runs)```
Sets the runs of this text all at once.
#### ```void xlnt::rich_text::add_run(const rich_text_run &t)```
Adds a new run to the end of the set of runs.
#### ```bool xlnt::rich_text::operator==(const rich_text &rhs) const```
Returns true if the runs that make up this text are identical to those in rhs.
#### ```bool xlnt::rich_text::operator==(const std::string &rhs) const```
Returns true if this text has a single unformatted run with text equal to rhs.
## Packaging Module
### manifest
#### ```void xlnt::manifest::clear()```
Unregisters all default and override type and all relationships and known parts.
#### ```std::vector<path> xlnt::manifest::parts() const```
Returns the path to all internal package parts registered as a source or target of a relationship.
#### ```bool xlnt::manifest::has_relationship(const path &source, relationship_type type) const```
Returns true if the manifest contains a relationship with the given type with part as the source.
#### ```bool xlnt::manifest::has_relationship(const path &source, const std::string &rel_id) const```
Returns true if the manifest contains a relationship with the given type with part as the source.
#### ```class relationship xlnt::manifest::relationship(const path &source, relationship_type type) const```
Returns the relationship with "source" as the source and with a type of "type". Throws a key_not_found exception if no such relationship is found.
#### ```class relationship xlnt::manifest::relationship(const path &source, const std::string &rel_id) const```
Returns the relationship with "source" as the source and with an ID of "rel_id". Throws a key_not_found exception if no such relationship is found.
#### ```std::vector<xlnt::relationship> xlnt::manifest::relationships(const path &source) const```
Returns all relationship with "source" as the source.
#### ```std::vector<xlnt::relationship> xlnt::manifest::relationships(const path &source, relationship_type type) const```
Returns all relationships with "source" as the source and with a type of "type".
#### ```path xlnt::manifest::canonicalize(const std::vector< xlnt::relationship > &rels) const```
Returns the canonical path of the chain of relationships by traversing through rels and forming the absolute combined path.
#### ```std::string xlnt::manifest::register_relationship(const uri &source, relationship_type type, const uri &target, target_mode mode)```
Registers a new relationship by specifying all of the relationship properties explicitly.
#### ```std::string xlnt::manifest::register_relationship(const class relationship &rel)```
Registers a new relationship already constructed elsewhere.
#### ```std::unordered_map<std::string, std::string> xlnt::manifest::unregister_relationship(const uri &source, const std::string &rel_id)```
Delete the relationship with the given id from source part. Returns a mapping of relationship IDs since IDs are shifted down. For example, if there are three relationships for part a.xml like [rId1, rId2, rId3] and rId2 is deleted, the resulting map would look like [rId3->rId2].
#### ```std::string xlnt::manifest::content_type(const path &part) const```
Given the path to a part, returns the content type of the part as a string.
#### ```bool xlnt::manifest::has_default_type(const std::string &extension) const```
Returns true if a default content type for the extension has been registered.
#### ```std::vector<std::string> xlnt::manifest::extensions_with_default_types() const```
Returns a vector of all extensions with registered default content types.
#### ```std::string xlnt::manifest::default_type(const std::string &extension) const```
Returns the registered default content type for parts of the given extension.
#### ```void xlnt::manifest::register_default_type(const std::string &extension, const std::string &type)```
Associates the given extension with the given content type.
#### ```void xlnt::manifest::unregister_default_type(const std::string &extension)```
Unregisters the default content type for the given extension.
#### ```bool xlnt::manifest::has_override_type(const path &part) const```
Returns true if a content type overriding the default content type has been registered for the given part.
#### ```std::string xlnt::manifest::override_type(const path &part) const```
Returns the override content type registered for the given part. Throws key_not_found exception if no override type was found.
#### ```std::vector<path> xlnt::manifest::parts_with_overriden_types() const```
Returns the path of every part in this manifest with an overriden content type.
#### ```void xlnt::manifest::register_override_type(const path &part, const std::string &type)```
Overrides any default type registered for the part's extension with the given content type.
#### ```void xlnt::manifest::unregister_override_type(const path &part)```
Unregisters the overriding content type of the given part.
### relationship
#### ```xlnt::relationship::relationship()```
Constructs a new empty relationship.
#### ```xlnt::relationship::relationship(const std::string &id, relationship_type t, const uri &source, const uri &target, xlnt::target_mode mode)```
Constructs a new relationship by specifying all of its properties.
#### ```std::string xlnt::relationship::id() const```
Returns a string of the form rId# that identifies the relationship.
#### ```relationship_type xlnt::relationship::type() const```
Returns the type of this relationship.
#### ```xlnt::target_mode xlnt::relationship::target_mode() const```
Returns whether the target of the relationship is internal or external to the package.
#### ```uri xlnt::relationship::source() const```
Returns the URI of the package part this relationship points to.
#### ```uri xlnt::relationship::target() const```
Returns the URI of the package part this relationship points to.
#### ```bool xlnt::relationship::operator==(const relationship &rhs) const```
Returns true if and only if rhs is equal to this relationship.
#### ```bool xlnt::relationship::operator!=(const relationship &rhs) const```
Returns true if and only if rhs is not equal to this relationship.
### uri
#### ```xlnt::uri::uri()```
Constructs an empty URI.
#### ```xlnt::uri::uri(const uri &base, const uri &relative)```
Constructs a URI by combining base with relative.
#### ```xlnt::uri::uri(const uri &base, const path &relative)```
Constructs a URI by combining base with relative path.
#### ```xlnt::uri::uri(const std::string &uri_string)```
Constructs a URI by parsing the given uri_string.
#### ```bool xlnt::uri::is_relative() const```
Returns true if this URI is relative.
#### ```bool xlnt::uri::is_absolute() const```
Returns true if this URI is not relative (i.e. absolute).
#### ```std::string xlnt::uri::scheme() const```
Returns the scheme of this URI. E.g. the scheme of http://user:pass@example.com is "http"
#### ```std::string xlnt::uri::authority() const```
Returns the authority of this URI. E.g. the authority of http://user:pass@example.com:80/document is "user:pass@example.com:80"
#### ```bool xlnt::uri::has_authentication() const```
Returns true if an authentication section is specified for this URI.
#### ```std::string xlnt::uri::authentication() const```
Returns the authentication of this URI. E.g. the authentication of http://user:pass@example.com is "user:pass"
#### ```std::string xlnt::uri::username() const```
Returns the username of this URI. E.g. the username of http://user:pass@example.com is "user"
#### ```std::string xlnt::uri::password() const```
Returns the password of this URI. E.g. the password of http://user:pass@example.com is "pass"
#### ```std::string xlnt::uri::host() const```
Returns the host of this URI. E.g. the host of http://example.com:80/document is "example.com"
#### ```bool xlnt::uri::has_port() const```
Returns true if a non-default port is specified for this URI.
#### ```std::size_t xlnt::uri::port() const```
Returns the port of this URI. E.g. the port of https://example.com:443/document is "443"
#### ```class path xlnt::uri::path() const```
Returns the path of this URI. E.g. the path of http://example.com/document is "/document"
#### ```bool xlnt::uri::has_query() const```
Returns true if this URI has a non-null query string section.
#### ```std::string xlnt::uri::query() const```
Returns the query string of this URI. E.g. the query of http://example.com/document?v=1&x=3#abc is "v=1&x=3"
#### ```bool xlnt::uri::has_fragment() const```
Returns true if this URI has a non-empty fragment section.
#### ```std::string xlnt::uri::fragment() const```
Returns the fragment section of this URI. E.g. the fragment of http://example.com/document#abc is "abc"
#### ```std::string xlnt::uri::to_string() const```
Returns a string representation of this URI.
#### ```uri xlnt::uri::make_absolute(const uri &base)```
If this URI is relative, an absolute URI will be returned by appending the path to the given absolute base URI.
#### ```uri xlnt::uri::make_reference(const uri &base)```
If this URI is absolute, a relative URI will be returned by removing the common base path from the given absolute base URI.
#### ```bool xlnt::uri::operator==(const uri &other) const```
Returns true if this URI is equivalent to other.
## Styles Module
### alignment
#### ```bool xlnt::alignment::shrink() const```
Returns true if shrink-to-fit has been enabled.
#### ```alignment& xlnt::alignment::shrink(bool shrink_to_fit)```
Sets whether the font size should be reduced until all of the text fits in a cell without wrapping.
#### ```bool xlnt::alignment::wrap() const```
Returns true if text-wrapping has been enabled.
#### ```alignment& xlnt::alignment::wrap(bool wrap_text)```
Sets whether text in a cell should continue to multiple lines if it doesn't fit in one line.
#### ```optional<int> xlnt::alignment::indent() const```
Returns the optional value of indentation width in number of spaces.
#### ```alignment& xlnt::alignment::indent(int indent_size)```
Sets the indent size in number of spaces from the side of the cell. This will only take effect when left or right horizontal alignment has also been set.
#### ```optional<int> xlnt::alignment::rotation() const```
Returns the optional value of rotation for text in the cell in degrees.
#### ```alignment& xlnt::alignment::rotation(int text_rotation)```
Sets the rotation for text in the cell in degrees.
#### ```optional<horizontal_alignment> xlnt::alignment::horizontal() const```
Returns the optional horizontal alignment.
#### ```alignment& xlnt::alignment::horizontal(horizontal_alignment horizontal)```
Sets the horizontal alignment.
#### ```optional<vertical_alignment> xlnt::alignment::vertical() const```
Returns the optional vertical alignment.
#### ```alignment& xlnt::alignment::vertical(vertical_alignment vertical)```
Sets the vertical alignment.
#### ```bool xlnt::alignment::operator==(const alignment &other) const```
Returns true if this alignment is equivalent to other.
#### ```bool xlnt::alignment::operator!=(const alignment &other) const```
Returns true if this alignment is not equivalent to other.
### border
#### ```static const std::vector<border_side>& xlnt::border::all_sides()```
Returns a vector containing all of the border sides to be used for iteration.
#### ```xlnt::border::border()```
Constructs a default border.
#### ```optional<border_property> xlnt::border::side(border_side s) const```
Returns the border properties of the given side.
#### ```border& xlnt::border::side(border_side s, const border_property &prop)```
Sets the border properties of the side s to prop.
#### ```optional<diagonal_direction> xlnt::border::diagonal() const```
Returns the diagonal direction of this border.
#### ```border& xlnt::border::diagonal(diagonal_direction dir)```
Sets the diagonal direction of this border to dir.
#### ```bool xlnt::border::operator==(const border &right) const```
Returns true if left is exactly equal to right.
#### ```bool xlnt::border::operator!=(const border &right) const```
Returns true if left is not exactly equal to right.
### border_property
#### ```optional<class color> xlnt::border::border_property::color() const```
Returns the color of the side.
#### ```border_property& xlnt::border::border_property::color(const xlnt::color &c)```
Sets the color of the side and returns a reference to the side properties.
#### ```optional<border_style> xlnt::border::border_property::style() const```
Returns the style of the side.
#### ```border_property& xlnt::border::border_property::style(border_style style)```
Sets the style of the side and returns a reference to the side properties.
#### ```bool xlnt::border::border_property::operator==(const border_property &right) const```
Returns true if left is exactly equal to right.
#### ```bool xlnt::border::border_property::operator!=(const border_property &right) const```
Returns true if left is not exactly equal to right.
### indexed_color
#### ```xlnt::indexed_color::indexed_color(std::size_t index)```
Constructs an indexed_color from an index.
#### ```std::size_t xlnt::indexed_color::index() const```
Returns the index this color points to.
#### ```void xlnt::indexed_color::index(std::size_t index)```
Sets the index to index.
### theme_color
#### ```xlnt::theme_color::theme_color(std::size_t index)```
Constructs a theme_color from an index.
#### ```std::size_t xlnt::theme_color::index() const```
Returns the index of the color in the theme this points to.
#### ```void xlnt::theme_color::index(std::size_t index)```
Sets the index of this color to index.
### rgb_color
#### ```xlnt::rgb_color::rgb_color(const std::string &hex_string)```
Constructs an RGB color from a string in the form #[aa]rrggbb
#### ```xlnt::rgb_color::rgb_color(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t a=255)```
Constructs an RGB color from red, green, and blue values in the range 0 to 255 plus an optional alpha which defaults to fully opaque.
#### ```std::string xlnt::rgb_color::hex_string() const```
Returns a string representation of this color in the form #aarrggbb
#### ```std::uint8_t xlnt::rgb_color::red() const```
Returns a byte representing the red component of this color
#### ```std::uint8_t xlnt::rgb_color::green() const```
Returns a byte representing the red component of this color
#### ```std::uint8_t xlnt::rgb_color::blue() const```
Returns a byte representing the blue component of this color
#### ```std::uint8_t xlnt::rgb_color::alpha() const```
Returns a byte representing the alpha component of this color
#### ```std::array<std::uint8_t, 3> xlnt::rgb_color::rgb() const```
Returns the red, green, and blue components of this color separately in an array in that order.
#### ```std::array<std::uint8_t, 4> xlnt::rgb_color::rgba() const```
Returns the red, green, blue, and alpha components of this color separately in an array in that order.
### color
#### ```static const color xlnt::color::black()```
Returns the color #000000
#### ```static const color xlnt::color::white()```
Returns the color #ffffff
#### ```static const color xlnt::color::red()```
Returns the color #ff0000
#### ```static const color xlnt::color::darkred()```
Returns the color #8b0000
#### ```static const color xlnt::color::blue()```
Returns the color #00ff00
#### ```static const color xlnt::color::darkblue()```
Returns the color #008b00
#### ```static const color xlnt::color::green()```
Returns the color #0000ff
#### ```static const color xlnt::color::darkgreen()```
Returns the color #00008b
#### ```static const color xlnt::color::yellow()```
Returns the color #ffff00
#### ```static const color xlnt::color::darkyellow()```
Returns the color #cccc00
#### ```xlnt::color::color()```
Constructs a default color
#### ```xlnt::color::color(const rgb_color &rgb)```
Constructs a color from a given RGB color
#### ```xlnt::color::color(const indexed_color &indexed)```
Constructs a color from a given indexed color
#### ```xlnt::color::color(const theme_color &theme)```
Constructs a color from a given theme color
#### ```color_type xlnt::color::type() const```
Returns the type of this color
#### ```bool xlnt::color::auto_() const```
Returns true if this color has been set to auto
#### ```void xlnt::color::auto_(bool value)```
Sets the auto property of this color to value
#### ```rgb_color xlnt::color::rgb() const```
Returns the internal indexed color representing this color. If this is not an RGB color, an invalid_attribute exception will be thrown.
#### ```indexed_color xlnt::color::indexed() const```
Returns the internal indexed color representing this color. If this is not an indexed color, an invalid_attribute exception will be thrown.
#### ```theme_color xlnt::color::theme() const```
Returns the internal indexed color representing this color. If this is not a theme color, an invalid_attribute exception will be thrown.
#### ```double xlnt::color::tint() const```
Returns the tint of this color.
#### ```void xlnt::color::tint(double tint)```
Sets the tint of this color to tint. Tints lighten or darken an existing color by multiplying the color with the tint.
#### ```bool xlnt::color::operator==(const color &other) const```
Returns true if this color is equivalent to other
#### ```bool xlnt::color::operator!=(const color &other) const```
Returns true if this color is not equivalent to other
### pattern_fill
#### ```xlnt::pattern_fill::pattern_fill()```
Constructs a default pattern fill with a none pattern and no colors.
#### ```pattern_fill_type xlnt::pattern_fill::type() const```
Returns the pattern used by this fill
#### ```pattern_fill& xlnt::pattern_fill::type(pattern_fill_type new_type)```
Sets the pattern of this fill and returns a reference to it.
#### ```optional<color> xlnt::pattern_fill::foreground() const```
Returns the optional foreground color of this fill
#### ```pattern_fill& xlnt::pattern_fill::foreground(const color &foreground)```
Sets the foreground color and returns a reference to this pattern.
#### ```optional<color> xlnt::pattern_fill::background() const```
Returns the optional background color of this fill
#### ```pattern_fill& xlnt::pattern_fill::background(const color &background)```
Sets the foreground color and returns a reference to this pattern.
#### ```bool xlnt::pattern_fill::operator==(const pattern_fill &other) const```
Returns true if this pattern fill is equivalent to other.
#### ```bool xlnt::pattern_fill::operator!=(const pattern_fill &other) const```
Returns true if this pattern fill is not equivalent to other.
### gradient_fill
#### ```xlnt::gradient_fill::gradient_fill()```
Constructs a default linear fill
#### ```gradient_fill_type xlnt::gradient_fill::type() const```
Returns the type of this gradient fill
#### ```gradient_fill& xlnt::gradient_fill::type(gradient_fill_type new_type)```
Sets the type of this gradient fill
#### ```gradient_fill& xlnt::gradient_fill::degree(double degree)```
Sets the angle of the gradient in degrees
#### ```double xlnt::gradient_fill::degree() const```
Returns the angle of the gradient
#### ```double xlnt::gradient_fill::left() const```
Returns the distance from the left where the gradient starts.
#### ```gradient_fill& xlnt::gradient_fill::left(double value)```
Sets the distance from the left where the gradient starts.
#### ```double xlnt::gradient_fill::right() const```
Returns the distance from the right where the gradient starts.
#### ```gradient_fill& xlnt::gradient_fill::right(double value)```
Sets the distance from the right where the gradient starts.
#### ```double xlnt::gradient_fill::top() const```
Returns the distance from the top where the gradient starts.
#### ```gradient_fill& xlnt::gradient_fill::top(double value)```
Sets the distance from the top where the gradient starts.
#### ```double xlnt::gradient_fill::bottom() const```
Returns the distance from the bottom where the gradient starts.
#### ```gradient_fill& xlnt::gradient_fill::bottom(double value)```
Sets the distance from the bottom where the gradient starts.
#### ```gradient_fill& xlnt::gradient_fill::add_stop(double position, color stop_color)```
Adds a gradient stop at position with the given color.
#### ```gradient_fill& xlnt::gradient_fill::clear_stops()```
Deletes all stops from the gradient.
#### ```std::unordered_map<double, color> xlnt::gradient_fill::stops() const```
Returns all of the gradient stops.
#### ```bool xlnt::gradient_fill::operator==(const gradient_fill &other) const```
Returns true if the gradient is equivalent to other.
#### ```bool xlnt::gradient_fill::operator!=(const gradient_fill &right) const```
Returns true if the gradient is not equivalent to other.
### fill
#### ```static fill xlnt::fill::solid(const color &fill_color)```
Helper method for the most common use case, setting the fill color of a cell to a single solid color. The foreground and background colors of a fill are not the same as the foreground and background colors of a cell. When setting a fill color in Excel, a new fill is created with the given color as the fill's fgColor and index color number 64 as the bgColor. This method creates a fill in the same way.
#### ```xlnt::fill::fill()```
Constructs a fill initialized as a none-type pattern fill with no foreground or background colors.
#### ```xlnt::fill::fill(const pattern_fill &pattern)```
Constructs a fill initialized as a pattern fill based on the given pattern.
#### ```xlnt::fill::fill(const gradient_fill &gradient)```
Constructs a fill initialized as a gradient fill based on the given gradient.
#### ```fill_type xlnt::fill::type() const```
Returns the fill_type of this fill depending on how it was constructed.
#### ```class gradient_fill xlnt::fill::gradient_fill() const```
Returns the gradient fill represented by this fill. Throws an invalid_attribute exception if this is not a gradient fill.
#### ```class pattern_fill xlnt::fill::pattern_fill() const```
Returns the pattern fill represented by this fill. Throws an invalid_attribute exception if this is not a pattern fill.
#### ```bool xlnt::fill::operator==(const fill &other) const```
Returns true if left is exactly equal to right.
#### ```bool xlnt::fill::operator!=(const fill &other) const```
Returns true if left is not exactly equal to right.
### font
#### ```undefinedundefined```
Text can be underlined in the enumerated ways
#### ```xlnt::font::font()```
Constructs a default font. Calibri, size 12
#### ```font& xlnt::font::bold(bool bold)```
Sets the bold state of the font to bold and returns a reference to the font.
#### ```bool xlnt::font::bold() const```
Returns the bold state of the font.
#### ```font& xlnt::font::superscript(bool superscript)```
Sets the bold state of the font to bold and returns a reference to the font.
#### ```bool xlnt::font::superscript() const```
Returns true if this font has a superscript applied.
#### ```font& xlnt::font::italic(bool italic)```
Sets the bold state of the font to bold and returns a reference to the font.
#### ```bool xlnt::font::italic() const```
Returns true if this font has italics applied.
#### ```font& xlnt::font::strikethrough(bool strikethrough)```
Sets the bold state of the font to bold and returns a reference to the font.
#### ```bool xlnt::font::strikethrough() const```
Returns true if this font has a strikethrough applied.
#### ```font& xlnt::font::outline(bool outline)```
Sets the bold state of the font to bold and returns a reference to the font.
#### ```bool xlnt::font::outline() const```
Returns true if this font has an outline applied.
#### ```font& xlnt::font::shadow(bool shadow)```
Sets the shadow state of the font to shadow and returns a reference to the font.
#### ```bool xlnt::font::shadow() const```
Returns true if this font has a shadow applied.
#### ```font& xlnt::font::underline(underline_style new_underline)```
Sets the underline state of the font to new_underline and returns a reference to the font.
#### ```bool xlnt::font::underlined() const```
Returns true if this font has any type of underline applied.
#### ```underline_style xlnt::font::underline() const```
Returns the particular style of underline this font has applied.
#### ```bool xlnt::font::has_size() const```
Returns true if this font has a defined size.
#### ```font& xlnt::font::size(double size)```
Sets the size of the font to size and returns a reference to the font.
#### ```double xlnt::font::size() const```
Returns the size of the font.
#### ```bool xlnt::font::has_name() const```
Returns true if this font has a particular face applied (e.g. "Comic Sans").
#### ```font& xlnt::font::name(const std::string &name)```
Sets the font face to name and returns a reference to the font.
#### ```std::string xlnt::font::name() const```
Returns the name of the font face.
#### ```bool xlnt::font::has_color() const```
Returns true if this font has a color applied.
#### ```font& xlnt::font::color(const color &c)```
Sets the color of the font to c and returns a reference to the font.
#### ```xlnt::color xlnt::font::color() const```
Returns the color that this font is using.
#### ```bool xlnt::font::has_family() const```
Returns true if this font has a family defined.
#### ```font& xlnt::font::family(std::size_t family)```
Sets the family index of the font to family and returns a reference to the font.
#### ```std::size_t xlnt::font::family() const```
Returns the family index for the font.
#### ```bool xlnt::font::has_charset() const```
Returns true if this font has a charset defined.
#### ```font& xlnt::font::charset(std::size_t charset)```
Sets the charset of the font to charset and returns a reference to the font.
#### ```std::size_t xlnt::font::charset() const```
Returns the charset of the font.
#### ```bool xlnt::font::has_scheme() const```
Returns true if this font has a scheme.
#### ```font& xlnt::font::scheme(const std::string &scheme)```
Sets the scheme of the font to scheme and returns a reference to the font.
#### ```std::string xlnt::font::scheme() const```
Returns the scheme of this font.
#### ```bool xlnt::font::operator==(const font &other) const```
Returns true if left is exactly equal to right.
#### ```bool xlnt::font::operator!=(const font &other) const```
Returns true if left is not exactly equal to right.
### format
#### ```friend struct detail::stylesheetundefined```
#### ```friend class detail::xlsx_producerundefined```
#### ```class alignment xlnt::format::alignment() const```
Returns the alignment of this format.
#### ```format xlnt::format::alignment(const xlnt::alignment &new_alignment, bool applied=true)```
Sets the alignment of this format to new_alignment. Applied, which defaults to true, determines whether the alignment should be enabled for cells using this format.
#### ```bool xlnt::format::alignment_applied() const```
Returns true if the alignment of this format should be applied to cells using it.
#### ```class border xlnt::format::border() const```
Returns the border of this format.
#### ```format xlnt::format::border(const xlnt::border &new_border, bool applied=true)```
Sets the border of this format to new_border. Applied, which defaults to true, determines whether the border should be enabled for cells using this format.
#### ```bool xlnt::format::border_applied() const```
Returns true if the border set for this format should be applied to cells using the format.
#### ```class fill xlnt::format::fill() const```
Returns the fill of this format.
#### ```format xlnt::format::fill(const xlnt::fill &new_fill, bool applied=true)```
Sets the fill of this format to new_fill. Applied, which defaults to true, determines whether the border should be enabled for cells using this format.
#### ```bool xlnt::format::fill_applied() const```
Returns true if the fill set for this format should be applied to cells using the format.
#### ```class font xlnt::format::font() const```
Returns the font of this format.
#### ```format xlnt::format::font(const xlnt::font &new_font, bool applied=true)```
Sets the font of this format to new_font. Applied, which defaults to true, determines whether the font should be enabled for cells using this format.
#### ```bool xlnt::format::font_applied() const```
Returns true if the font set for this format should be applied to cells using the format.
#### ```class number_format xlnt::format::number_format() const```
Returns the number format of this format.
#### ```format xlnt::format::number_format(const xlnt::number_format &new_number_format, bool applied=true)```
Sets the number format of this format to new_number_format. Applied, which defaults to true, determines whether the number format should be enabled for cells using this format.
#### ```bool xlnt::format::number_format_applied() const```
Returns true if the number_format set for this format should be applied to cells using the format.
#### ```class protection xlnt::format::protection() const```
Returns the protection of this format.
#### ```bool xlnt::format::protection_applied() const```
Returns true if the protection set for this format should be applied to cells using the format.
#### ```format xlnt::format::protection(const xlnt::protection &new_protection, bool applied=true)```
Sets the protection of this format to new_protection. Applied, which defaults to true, determines whether the protection should be enabled for cells using this format.
#### ```bool xlnt::format::pivot_button() const```
Returns true if the pivot table interface is enabled for this format.
#### ```void xlnt::format::pivot_button(bool show)```
If show is true, a pivot table interface will be displayed for cells using this format.
#### ```bool xlnt::format::quote_prefix() const```
Returns true if this format should add a single-quote prefix for all text values.
#### ```void xlnt::format::quote_prefix(bool quote)```
If quote is true, enables a single-quote prefix for all text values in cells using this format (e.g. "abc" will appear as "'abc"). The text will also not be stored in sharedStrings when this is enabled.
#### ```bool xlnt::format::has_style() const```
Returns true if this format has a corresponding style applied.
#### ```void xlnt::format::clear_style()```
Removes the style from this format if it exists.
#### ```format xlnt::format::style(const std::string &name)```
Sets the style of this format to a style with the given name.
#### ```format xlnt::format::style(const class style &new_style)```
Sets the style of this format to new_style.
#### ```class style xlnt::format::style()```
Returns the style of this format. If it has no style, an invalid_parameter exception will be thrown.
#### ```const class style xlnt::format::style() const```
Returns the style of this format. If it has no style, an invalid_parameters exception will be thrown.
### number_format
#### ```static const number_format xlnt::number_format::general()```
Number format "General"
#### ```static const number_format xlnt::number_format::text()```
Number format "@"
#### ```static const number_format xlnt::number_format::number()```
Number format "0"
#### ```static const number_format xlnt::number_format::number_00()```
Number format "00"
#### ```static const number_format xlnt::number_format::number_comma_separated1()```
Number format "#,##0.00"
#### ```static const number_format xlnt::number_format::percentage()```
Number format "0%"
#### ```static const number_format xlnt::number_format::percentage_00()```
Number format "0.00%"
#### ```static const number_format xlnt::number_format::date_yyyymmdd2()```
Number format "yyyy-mm-dd"
#### ```static const number_format xlnt::number_format::date_yymmdd()```
Number format "yy-mm-dd"
#### ```static const number_format xlnt::number_format::date_ddmmyyyy()```
Number format "dd/mm/yy"
#### ```static const number_format xlnt::number_format::date_dmyslash()```
Number format "d/m/yy"
#### ```static const number_format xlnt::number_format::date_dmyminus()```
Number format "d-m-yy"
#### ```static const number_format xlnt::number_format::date_dmminus()```
Number format "d-m"
#### ```static const number_format xlnt::number_format::date_myminus()```
Number format "m-yy"
#### ```static const number_format xlnt::number_format::date_xlsx14()```
Number format "mm-dd-yy"
#### ```static const number_format xlnt::number_format::date_xlsx15()```
Number format "d-mmm-yy"
#### ```static const number_format xlnt::number_format::date_xlsx16()```
Number format "d-mmm"
#### ```static const number_format xlnt::number_format::date_xlsx17()```
Number format "mmm-yy"
#### ```static const number_format xlnt::number_format::date_xlsx22()```
Number format "m/d/yy h:mm"
#### ```static const number_format xlnt::number_format::date_datetime()```
Number format "yyyy-mm-dd h:mm:ss"
#### ```static const number_format xlnt::number_format::date_time1()```
Number format "h:mm AM/PM"
#### ```static const number_format xlnt::number_format::date_time2()```
Number format "h:mm:ss AM/PM"
#### ```static const number_format xlnt::number_format::date_time3()```
Number format "h:mm"
#### ```static const number_format xlnt::number_format::date_time4()```
Number format "h:mm:ss"
#### ```static const number_format xlnt::number_format::date_time5()```
Number format "mm:ss"
#### ```static const number_format xlnt::number_format::date_time6()```
Number format "h:mm:ss"
#### ```static bool xlnt::number_format::is_builtin_format(std::size_t builtin_id)```
Returns true if the given format ID corresponds to a known builtin format.
#### ```static const number_format& xlnt::number_format::from_builtin_id(std::size_t builtin_id)```
Returns the format with the given ID. Thows an invalid_parameter exception if builtin_id is not a valid ID.
#### ```xlnt::number_format::number_format()```
Constructs a default number_format equivalent to "General"
#### ```xlnt::number_format::number_format(std::size_t builtin_id)```
Constructs a number format equivalent to that returned from number_format::from_builtin_id(builtin_id).
#### ```xlnt::number_format::number_format(const std::string &code)```
Constructs a number format from a code string. If the string matches a builtin ID, its ID will also be set to match the builtin ID.
#### ```xlnt::number_format::number_format(const std::string &code, std::size_t custom_id)```
Constructs a number format from a code string and custom ID. Custom ID should generally be >= 164.
#### ```void xlnt::number_format::format_string(const std::string &format_code)```
Sets the format code of this number format to format_code.
#### ```void xlnt::number_format::format_string(const std::string &format_code, std::size_t custom_id)```
Sets the format code of this number format to format_code and the ID to custom_id.
#### ```std::string xlnt::number_format::format_string() const```
Returns the format code this number format uses.
#### ```bool xlnt::number_format::has_id() const```
Returns true if this number format has an ID.
#### ```void xlnt::number_format::id(std::size_t id)```
Sets the ID of this number format to id.
#### ```std::size_t xlnt::number_format::id() const```
Returns the ID of this format.
#### ```std::string xlnt::number_format::format(const std::string &text) const```
Returns text formatted according to this number format's format code.
#### ```std::string xlnt::number_format::format(long double number, calendar base_date) const```
Returns number formatted according to this number format's format code with the given base date.
#### ```bool xlnt::number_format::is_date_format() const```
Returns true if this format code returns a number formatted as a date.
#### ```bool xlnt::number_format::operator==(const number_format &other) const```
Returns true if this format is equivalent to other.
#### ```bool xlnt::number_format::operator!=(const number_format &other) const```
Returns true if this format is not equivalent to other.
### protection
#### ```static protection xlnt::protection::unlocked_and_visible()```
Returns an unlocked and unhidden protection object.
#### ```static protection xlnt::protection::locked_and_visible()```
Returns a locked and unhidden protection object.
#### ```static protection xlnt::protection::unlocked_and_hidden()```
Returns an unlocked and hidden protection object.
#### ```static protection xlnt::protection::locked_and_hidden()```
Returns a locked and hidden protection object.
#### ```xlnt::protection::protection()```
Constructs a default unlocked unhidden protection object.
#### ```bool xlnt::protection::locked() const```
Returns true if cells using this protection should be locked.
#### ```protection& xlnt::protection::locked(bool locked)```
Sets the locked state of the protection to locked and returns a reference to the protection.
#### ```bool xlnt::protection::hidden() const```
Returns true if cells using this protection should be hidden.
#### ```protection& xlnt::protection::hidden(bool hidden)```
Sets the hidden state of the protection to hidden and returns a reference to the protection.
#### ```bool xlnt::protection::operator==(const protection &other) const```
Returns true if this protections is equivalent to right.
#### ```bool xlnt::protection::operator!=(const protection &other) const```
Returns true if this protection is not equivalent to right.
### style
#### ```friend struct detail::stylesheetundefined```
#### ```friend class detail::xlsx_consumerundefined```
#### ```xlnt::style::style()=delete```
Delete zero-argument constructor
#### ```xlnt::style::style(const style &other)=default```
Default copy constructor. Constructs a style using the same PIMPL as other.
#### ```std::string xlnt::style::name() const```
Returns the name of this style.
#### ```style xlnt::style::name(const std::string &name)```
Sets the name of this style to name.
#### ```bool xlnt::style::hidden() const```
Returns true if this style is hidden.
#### ```style xlnt::style::hidden(bool value)```
Sets the hidden state of this style to value. A hidden style will not be shown in the list of selectable styles in the UI, but will still apply its formatting to cells using it.
#### ```bool xlnt::style::custom_builtin() const```
Returns true if this is a builtin style that has been customized and should therefore be persisted in the workbook.
#### ```std::size_t xlnt::style::builtin_id() const```
Returns the index of the builtin style that this style is an instance of or is a customized version thereof. If style::builtin() is false, this will throw an invalid_attribute exception.
#### ```bool xlnt::style::builtin() const```
Returns true if this is a builtin style.
#### ```class alignment xlnt::style::alignment() const```
Returns the alignment of this style.
#### ```bool xlnt::style::alignment_applied() const```
Returns true if the alignment of this style should be applied to cells using it.
#### ```style xlnt::style::alignment(const xlnt::alignment &new_alignment, bool applied=true)```
Sets the alignment of this style to new_alignment. Applied, which defaults to true, determines whether the alignment should be enabled for cells using this style.
#### ```class border xlnt::style::border() const```
Returns the border of this style.
#### ```bool xlnt::style::border_applied() const```
Returns true if the border set for this style should be applied to cells using the style.
#### ```style xlnt::style::border(const xlnt::border &new_border, bool applied=true)```
Sets the border of this style to new_border. Applied, which defaults to true, determines whether the border should be enabled for cells using this style.
#### ```class fill xlnt::style::fill() const```
Returns the fill of this style.
#### ```bool xlnt::style::fill_applied() const```
Returns true if the fill set for this style should be applied to cells using the style.
#### ```style xlnt::style::fill(const xlnt::fill &new_fill, bool applied=true)```
Sets the fill of this style to new_fill. Applied, which defaults to true, determines whether the border should be enabled for cells using this style.
#### ```class font xlnt::style::font() const```
Returns the font of this style.
#### ```bool xlnt::style::font_applied() const```
Returns true if the font set for this style should be applied to cells using the style.
#### ```style xlnt::style::font(const xlnt::font &new_font, bool applied=true)```
Sets the font of this style to new_font. Applied, which defaults to true, determines whether the font should be enabled for cells using this style.
#### ```class number_format xlnt::style::number_format() const```
Returns the number_format of this style.
#### ```bool xlnt::style::number_format_applied() const```
Returns true if the number_format set for this style should be applied to cells using the style.
#### ```style xlnt::style::number_format(const xlnt::number_format &new_number_format, bool applied=true)```
Sets the number format of this style to new_number_format. Applied, which defaults to true, determines whether the number format should be enabled for cells using this style.
#### ```class protection xlnt::style::protection() const```
Returns the protection of this style.
#### ```bool xlnt::style::protection_applied() const```
Returns true if the protection set for this style should be applied to cells using the style.
#### ```style xlnt::style::protection(const xlnt::protection &new_protection, bool applied=true)```
Sets the border of this style to new_protection. Applied, which defaults to true, determines whether the protection should be enabled for cells using this style.
#### ```bool xlnt::style::pivot_button() const```
Returns true if the pivot table interface is enabled for this style.
#### ```void xlnt::style::pivot_button(bool show)```
If show is true, a pivot table interface will be displayed for cells using this style.
#### ```bool xlnt::style::quote_prefix() const```
Returns true if this style should add a single-quote prefix for all text values.
#### ```void xlnt::style::quote_prefix(bool quote)```
If quote is true, enables a single-quote prefix for all text values in cells using this style (e.g. "abc" will appear as "'abc"). The text will also not be stored in sharedStrings when this is enabled.
#### ```bool xlnt::style::operator==(const style &other) const```
Returns true if this style is equivalent to other.
#### ```bool xlnt::style::operator!=(const style &other) const```
Returns true if this style is not equivalent to other.
## Utils Module
### date
#### ```int xlnt::date::yearundefined```
The year
#### ```int xlnt::date::monthundefined```
The month
#### ```int xlnt::date::dayundefined```
The day
#### ```static date xlnt::date::today()```
Return the current date according to the system time.
#### ```static date xlnt::date::from_number(int days_since_base_year, calendar base_date)```
Return a date by adding days_since_base_year to base_date. This includes leap years.
#### ```xlnt::date::date(int year_, int month_, int day_)```
Constructs a data from a given year, month, and day.
#### ```int xlnt::date::to_number(calendar base_date) const```
Return the number of days between this date and base_date.
#### ```int xlnt::date::weekday() const```
Calculates and returns the day of the week that this date represents in the range 0 to 6 where 0 represents Sunday.
#### ```bool xlnt::date::operator==(const date &comparand) const```
Return true if this date is equal to comparand.
### datetime
#### ```int xlnt::datetime::yearundefined```
The year
#### ```int xlnt::datetime::monthundefined```
The month
#### ```int xlnt::datetime::dayundefined```
The day
#### ```int xlnt::datetime::hourundefined```
The hour
#### ```int xlnt::datetime::minuteundefined```
The minute
#### ```int xlnt::datetime::secondundefined```
The second
#### ```int xlnt::datetime::microsecondundefined```
The microsecond
#### ```static datetime xlnt::datetime::now()```
Returns the current date and time according to the system time.
#### ```static datetime xlnt::datetime::today()```
Returns the current date and time according to the system time. This is equivalent to datetime::now().
#### ```static datetime xlnt::datetime::from_number(long double number, calendar base_date)```
Returns a datetime from number by converting the integer part into a date and the fractional part into a time according to date::from_number and time::from_number.
#### ```static datetime xlnt::datetime::from_iso_string(const std::string &iso_string)```
Returns a datetime equivalent to the ISO-formatted string iso_string.
#### ```xlnt::datetime::datetime(const date &d, const time &t)```
Constructs a datetime from a date and a time.
#### ```xlnt::datetime::datetime(int year_, int month_, int day_, int hour_=0, int minute_=0, int second_=0, int microsecond_=0)```
Constructs a datetime from a year, month, and day plus optional hour, minute, second, and microsecond.
#### ```std::string xlnt::datetime::to_string() const```
Returns a string represenation of this date and time.
#### ```std::string xlnt::datetime::to_iso_string() const```
Returns an ISO-formatted string representation of this date and time.
#### ```long double xlnt::datetime::to_number(calendar base_date) const```
Returns this datetime as a number of seconds since 1900 or 1904 (depending on base_date provided).
#### ```bool xlnt::datetime::operator==(const datetime &comparand) const```
Returns true if this datetime is equivalent to comparand.
#### ```int xlnt::datetime::weekday() const```
Calculates and returns the day of the week that this date represents in the range 0 to 6 where 0 represents Sunday.
### exception
#### ```xlnt::exception::exception(const std::string &message)```
Constructs an exception with a message. This message will be returned by std::exception::what(), an inherited member of this class.
#### ```xlnt::exception::exception(const exception &)=default```
Default copy constructor.
#### ```virtual xlnt::exception::~exception()```
Destructor
#### ```void xlnt::exception::message(const std::string &message)```
Sets the message after the xlnt::exception is constructed. This can show more specific information than std::exception::what().
### invalid_parameter
#### ```xlnt::invalid_parameter::invalid_parameter()```
Default constructor.
#### ```xlnt::invalid_parameter::invalid_parameter(const invalid_parameter &)=default```
Default copy constructor.
#### ```virtual xlnt::invalid_parameter::~invalid_parameter()```
Destructor
### invalid_sheet_title
#### ```xlnt::invalid_sheet_title::invalid_sheet_title(const std::string &title)```
Default constructor.
#### ```xlnt::invalid_sheet_title::invalid_sheet_title(const invalid_sheet_title &)=default```
Default copy constructor.
#### ```virtual xlnt::invalid_sheet_title::~invalid_sheet_title()```
Destructor
### missing_number_format
#### ```xlnt::missing_number_format::missing_number_format()```
Default constructor.
#### ```xlnt::missing_number_format::missing_number_format(const missing_number_format &)=default```
Default copy constructor.
#### ```virtual xlnt::missing_number_format::~missing_number_format()```
Destructor
### invalid_file
#### ```xlnt::invalid_file::invalid_file(const std::string &filename)```
Constructs an invalid_file exception thrown when attempt to access the given filename.
#### ```xlnt::invalid_file::invalid_file(const invalid_file &)=default```
Default copy constructor.
#### ```virtual xlnt::invalid_file::~invalid_file()```
Destructor
### illegal_character
#### ```xlnt::illegal_character::illegal_character(char c)```
Constructs an illegal_character exception thrown as a result of the given character.
#### ```xlnt::illegal_character::illegal_character(const illegal_character &)=default```
Default copy constructor.
#### ```virtual xlnt::illegal_character::~illegal_character()```
Destructor
### invalid_data_type
#### ```xlnt::invalid_data_type::invalid_data_type()```
Default constructor.
#### ```xlnt::invalid_data_type::invalid_data_type(const invalid_data_type &)=default```
Default copy constructor.
#### ```virtual xlnt::invalid_data_type::~invalid_data_type()```
Destructor
### invalid_column_index
#### ```xlnt::invalid_column_index::invalid_column_index()```
Default constructor.
#### ```xlnt::invalid_column_index::invalid_column_index(const invalid_column_index &)=default```
Default copy constructor.
#### ```virtual xlnt::invalid_column_index::~invalid_column_index()```
Destructor
### invalid_cell_reference
#### ```xlnt::invalid_cell_reference::invalid_cell_reference(column_t column, row_t row)```
Constructs an invalid_cell_reference exception for the given column and row.
#### ```xlnt::invalid_cell_reference::invalid_cell_reference(const std::string &reference_string)```
Constructs an invalid_cell_reference exception for the given string.
#### ```xlnt::invalid_cell_reference::invalid_cell_reference(const invalid_cell_reference &)=default```
Default copy constructor.
#### ```virtual xlnt::invalid_cell_reference::~invalid_cell_reference()```
Destructor
### invalid_attribute
#### ```xlnt::invalid_attribute::invalid_attribute()```
Default constructor.
#### ```xlnt::invalid_attribute::invalid_attribute(const invalid_attribute &)=default```
Default copy constructor.
#### ```virtual xlnt::invalid_attribute::~invalid_attribute()```
Destructor
### key_not_found
#### ```xlnt::key_not_found::key_not_found()```
Default constructor.
#### ```xlnt::key_not_found::key_not_found(const key_not_found &)=default```
Default copy constructor.
#### ```virtual xlnt::key_not_found::~key_not_found()```
Destructor
### no_visible_worksheets
#### ```xlnt::no_visible_worksheets::no_visible_worksheets()```
Default constructor.
#### ```xlnt::no_visible_worksheets::no_visible_worksheets(const no_visible_worksheets &)=default```
Default copy constructor.
#### ```virtual xlnt::no_visible_worksheets::~no_visible_worksheets()```
Destructor
### unhandled_switch_case
#### ```xlnt::unhandled_switch_case::unhandled_switch_case()```
Default constructor.
#### ```xlnt::unhandled_switch_case::unhandled_switch_case(const unhandled_switch_case &)=default```
Default copy constructor.
#### ```virtual xlnt::unhandled_switch_case::~unhandled_switch_case()```
Destructor
### unsupported
#### ```xlnt::unsupported::unsupported(const std::string &message)```
Constructs an unsupported exception with a message describing the unsupported feature.
#### ```xlnt::unsupported::unsupported(const unsupported &)=default```
Default copy constructor.
#### ```virtual xlnt::unsupported::~unsupported()```
Destructor
### optional
#### ```xlnt::optional< T >::optional()```
Default contructor. is_set() will be false initially.
#### ```xlnt::optional< T >::optional(const T &value)```
Constructs this optional with a value.
#### ```bool xlnt::optional< T >::is_set() const```
Returns true if this object currently has a value set. This should be called before accessing the value with optional::get().
#### ```void xlnt::optional< T >::set(const T &value)```
Sets the value to value.
#### ```T& xlnt::optional< T >::get()```
Gets the value. If no value has been initialized in this object, an xlnt::invalid_attribute exception will be thrown.
#### ```const T& xlnt::optional< T >::get() const```
Gets the value. If no value has been initialized in this object, an xlnt::invalid_attribute exception will be thrown.
#### ```void xlnt::optional< T >::clear()```
Resets the internal value using its default constructor. After this is called, is_set() will return false until a new value is provided.
#### ```optional& xlnt::optional< T >::operator=(const T &rhs)```
Assignment operator. Equivalent to setting the value using optional::set.
#### ```bool xlnt::optional< T >::operator==(const optional< T > &other) const```
Returns true if neither this nor other have a value or both have a value and those values are equal according to their equality operator.
### path
#### ```static char xlnt::path::system_separator()```
The system-specific path separator character (e.g. '/' or '\').
#### ```xlnt::path::path()```
Construct an empty path.
#### ```xlnt::path::path(const std::string &path_string)```
Counstruct a path from a string representing the path.
#### ```xlnt::path::path(const std::string &path_string, char sep)```
Construct a path from a string with an explicit directory seprator.
#### ```bool xlnt::path::is_relative() const```
Return true iff this path doesn't begin with / (or a drive letter on Windows).
#### ```bool xlnt::path::is_absolute() const```
Return true iff path::is_relative() is false.
#### ```bool xlnt::path::is_root() const```
Return true iff this path is the root directory.
#### ```path xlnt::path::parent() const```
Return a new path that points to the directory containing the current path Return the path unchanged if this path is the absolute or relative root.
#### ```std::string xlnt::path::filename() const```
Return the last component of this path.
#### ```std::string xlnt::path::extension() const```
Return the part of the path following the last dot in the filename.
#### ```std::pair<std::string, std::string> xlnt::path::split_extension() const```
Return a pair of strings resulting from splitting the filename on the last dot.
#### ```std::vector<std::string> xlnt::path::split() const```
Create a string representing this path separated by the provided separator or the system-default separator if not provided.
#### ```std::string xlnt::path::string() const```
Create a string representing this path separated by the provided separator or the system-default separator if not provided.
#### ```path xlnt::path::resolve(const path &base_path) const```
If this path is relative, append each component of this path to base_path and return the resulting absolute path. Otherwise, the the current path will be returned and base_path will be ignored.
#### ```path xlnt::path::relative_to(const path &base_path) const```
The inverse of path::resolve. Creates a relative path from an absolute path by removing the common root between base_path and this path. If the current path is already relative, return it unchanged.
#### ```bool xlnt::path::exists() const```
Return true iff the file or directory pointed to by this path exists on the filesystem.
#### ```bool xlnt::path::is_directory() const```
Return true if the file or directory pointed to by this path is a directory.
#### ```bool xlnt::path::is_file() const```
Return true if the file or directory pointed to by this path is a regular file.
#### ```std::string xlnt::path::read_contents() const```
Open the file pointed to by this path and return a string containing the files contents.
#### ```path xlnt::path::append(const std::string &to_append) const```
Append the provided part to this path and return the result.
#### ```path xlnt::path::append(const path &to_append) const```
Append the provided part to this path and return the result.
#### ```bool xlnt::path::operator==(const path &other) const```
Returns true if left path is equal to right path.
### path >
#### ```size_t std::hash< xlnt::path >::operator()(const xlnt::path &p) const```
Returns a hashed represenation of the given path.
### scoped_enum_hash
#### ```std::size_t xlnt::scoped_enum_hash< Enum >::operator()(Enum e) const```
Cast the enumeration e to a std::size_t and hash that value using std::hash.
### time
#### ```int xlnt::time::hourundefined```
The hour
#### ```int xlnt::time::minuteundefined```
The minute
#### ```int xlnt::time::secondundefined```
The second
#### ```int xlnt::time::microsecondundefined```
The microsecond
#### ```static time xlnt::time::now()```
Return the current time according to the system time.
#### ```static time xlnt::time::from_number(long double number)```
Return a time from a number representing a fraction of a day. The integer part of number will be ignored. 0.5 would return time(12, 0, 0, 0) or noon, halfway through the day.
#### ```xlnt::time::time(int hour_=0, int minute_=0, int second_=0, int microsecond_=0)```
Constructs a time object from an optional hour, minute, second, and microsecond.
#### ```xlnt::time::time(const std::string &time_string)```
Constructs a time object from a string representing the time.
#### ```long double xlnt::time::to_number() const```
Returns a numeric representation of the time in the range 0-1 where the value is equal to the fraction of the day elapsed.
#### ```bool xlnt::time::operator==(const time &comparand) const```
Returns true if this time is equivalent to comparand.
### timedelta
#### ```int xlnt::timedelta::daysundefined```
The days
#### ```int xlnt::timedelta::hoursundefined```
The hours
#### ```int xlnt::timedelta::minutesundefined```
The minutes
#### ```int xlnt::timedelta::secondsundefined```
The seconds
#### ```int xlnt::timedelta::microsecondsundefined```
The microseconds
#### ```static timedelta xlnt::timedelta::from_number(long double number)```
Returns a timedelta from a number representing the factional number of days elapsed.
#### ```xlnt::timedelta::timedelta()```
Constructs a timedelta equal to zero.
#### ```xlnt::timedelta::timedelta(int days_, int hours_, int minutes_, int seconds_, int microseconds_)```
Constructs a timedelta from a number of days, hours, minutes, seconds, and microseconds.
#### ```long double xlnt::timedelta::to_number() const```
Returns a numeric representation of this timedelta as a fractional number of days.
### variant
#### ```undefinedundefined```
The possible types a variant can hold.
#### ```xlnt::variant::variant()```
Default constructor. Creates a null-type variant.
#### ```xlnt::variant::variant(const std::string &value)```
Creates a string-type variant with the given value.
#### ```xlnt::variant::variant(const char *value)```
Creates a string-type variant with the given value.
#### ```xlnt::variant::variant(int value)```
Creates a i4-type variant with the given value.
#### ```xlnt::variant::variant(bool value)```
Creates a bool-type variant with the given value.
#### ```xlnt::variant::variant(const datetime &value)```
Creates a date-type variant with the given value.
#### ```xlnt::variant::variant(const std::initializer_list< int > &value)```
Creates a vector_i4-type variant with the given value.
#### ```xlnt::variant::variant(const std::vector< int > &value)```
Creates a vector_i4-type variant with the given value.
#### ```xlnt::variant::variant(const std::initializer_list< const char *> &value)```
Creates a vector_string-type variant with the given value.
#### ```xlnt::variant::variant(const std::vector< const char *> &value)```
Creates a vector_string-type variant with the given value.
#### ```xlnt::variant::variant(const std::initializer_list< std::string > &value)```
Creates a vector_string-type variant with the given value.
#### ```xlnt::variant::variant(const std::vector< std::string > &value)```
Creates a vector_string-type variant with the given value.
#### ```xlnt::variant::variant(const std::vector< variant > &value)```
Creates a vector_variant-type variant with the given value.
#### ```bool xlnt::variant::is(type t) const```
Returns true if this variant is of type t.
#### ```T xlnt::variant::get() const```
Returns the value of this variant as type T. An exception will be thrown if the types are not convertible.
#### ```type xlnt::variant::value_type() const```
Returns the type of this variant.
## Workbook Module
### calculation_properties
#### ```std::size_t xlnt::calculation_properties::calc_idundefined```
The version of calculation engine used to calculate cell formula values. If this is older than the version of the Excel calculation engine opening the workbook, cell values will be recalculated.
#### ```bool xlnt::calculation_properties::concurrent_calcundefined```
If this is true, concurrent calculation will be enabled for the workbook.
### document_security
#### ```bool xlnt::document_security::lock_revisionundefined```
If true, the workbook is locked for revisions.
#### ```bool xlnt::document_security::lock_structureundefined```
If true, worksheets can't be moved, renamed, (un)hidden, inserted, or deleted.
#### ```bool xlnt::document_security::lock_windowsundefined```
If true, workbook windows will be opened at the same position with the same size every time they are loaded.
#### ```lock_verifier xlnt::document_security::revision_lockundefined```
The settings to allow the revision lock to be removed.
#### ```lock_verifier xlnt::document_security::workbook_lockundefined```
The settings to allow the structure and windows lock to be removed.
#### ```xlnt::document_security::document_security()```
Constructs a new document security object with default values.
### lock_verifier
#### ```std::string xlnt::document_security::lock_verifier::hash_algorithmundefined```
The algorithm used to create and verify this lock.
#### ```std::string xlnt::document_security::lock_verifier::saltundefined```
The initial salt combined with the password used to prevent rainbow table attacks
#### ```std::string xlnt::document_security::lock_verifier::hashundefined```
The actual hash value represented as a string
#### ```std::size_t xlnt::document_security::lock_verifier::spin_countundefined```
The number of times the hash should be applied to the password combined with the salt. This allows the difficulty of the hash to be increased as computing power increases.
### external_book
### named_range
#### ```using xlnt::named_range::target = std::pair<worksheet, range_reference>undefined```
Type alias for the combination of sheet and range this named_range points to.
#### ```xlnt::named_range::named_range()```
Constructs a named range that has no name and has no targets.
#### ```xlnt::named_range::named_range(const named_range &other)```
Constructs a named range by copying its name and targets from other.
#### ```xlnt::named_range::named_range(const std::string &name, const std::vector< target > &targets)```
Constructs a named range with the given name and targets.
#### ```std::string xlnt::named_range::name() const```
Returns the name of this range.
#### ```const std::vector<target>& xlnt::named_range::targets() const```
Returns the set of targets of this named range as a vector.
#### ```named_range& xlnt::named_range::operator=(const named_range &other)```
Assigns the name and targets of this named_range to that of other.
### theme
### workbook
#### ```using xlnt::workbook::iterator = worksheet_iteratorundefined```
typedef for the iterator used for iterating through this workbook (non-const) in a range-based for loop.
#### ```using xlnt::workbook::const_iterator = const_worksheet_iteratorundefined```
typedef for the iterator used for iterating through this workbook (const) in a range-based for loop.
#### ```using xlnt::workbook::reverse_iterator = std::reverse_iterator<iterator>undefined```
typedef for the iterator used for iterating through this workbook (non-const) in a range-based for loop in reverse order using std::make_reverse_iterator.
#### ```using xlnt::workbook::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined```
typedef for the iterator used for iterating through this workbook (const) in a range-based for loop in reverse order using std::make_reverse_iterator.
#### ```friend class detail::xlsx_consumerundefined```
#### ```friend class detail::xlsx_producerundefined```
#### ```static workbook xlnt::workbook::empty()```
Constructs and returns an empty workbook similar to a default. Excel workbook
#### ```xlnt::workbook::workbook()```
Default constructor. Constructs a workbook containing a single empty worksheet using workbook::empty().
#### ```xlnt::workbook::workbook(workbook &&other)```
Move constructor. Constructs a workbook from existing workbook, other.
#### ```xlnt::workbook::workbook(const workbook &other)```
Copy constructor. Constructs this workbook from existing workbook, other.
#### ```xlnt::workbook::~workbook()```
Destroys this workbook, deallocating all internal storage space. Any pimpl wrapper classes (e.g. cell) pointing into this workbook will be invalid after this is executed.
#### ```worksheet xlnt::workbook::create_sheet()```
Creates and returns a sheet after the last sheet in this workbook.
#### ```worksheet xlnt::workbook::create_sheet(std::size_t index)```
Creates and returns a sheet at the specified index.
#### ```worksheet xlnt::workbook::create_sheet_with_rel(const std::string &title, const relationship &rel)```
TODO: This should be private...
#### ```worksheet xlnt::workbook::copy_sheet(worksheet worksheet)```
Creates and returns a new sheet after the last sheet initializing it with all of the data from the provided worksheet.
#### ```worksheet xlnt::workbook::copy_sheet(worksheet worksheet, std::size_t index)```
Creates and returns a new sheet at the specified index initializing it with all of the data from the provided worksheet.
#### ```worksheet xlnt::workbook::active_sheet()```
Returns the worksheet that is determined to be active. An active sheet is that which is initially shown by the spreadsheet editor.
#### ```worksheet xlnt::workbook::sheet_by_title(const std::string &title)```
Returns the worksheet with the given name. This may throw an exception if the sheet isn't found. Use workbook::contains(const std::string &) to make sure the sheet exists before calling this method.
#### ```const worksheet xlnt::workbook::sheet_by_title(const std::string &title) const```
Returns the worksheet with the given name. This may throw an exception if the sheet isn't found. Use workbook::contains(const std::string &) to make sure the sheet exists before calling this method.
#### ```worksheet xlnt::workbook::sheet_by_index(std::size_t index)```
Returns the worksheet at the given index. This will throw an exception if index is greater than or equal to the number of sheets in this workbook.
#### ```const worksheet xlnt::workbook::sheet_by_index(std::size_t index) const```
Returns the worksheet at the given index. This will throw an exception if index is greater than or equal to the number of sheets in this workbook.
#### ```worksheet xlnt::workbook::sheet_by_id(std::size_t id)```
Returns the worksheet with a sheetId of id. Sheet IDs are arbitrary numbers that uniquely identify a sheet. Most users won't need this.
#### ```const worksheet xlnt::workbook::sheet_by_id(std::size_t id) const```
Returns the worksheet with a sheetId of id. Sheet IDs are arbitrary numbers that uniquely identify a sheet. Most users won't need this.
#### ```bool xlnt::workbook::contains(const std::string &title) const```
Returns true if this workbook contains a sheet with the given title.
#### ```std::size_t xlnt::workbook::index(worksheet worksheet)```
Returns the index of the given worksheet. The worksheet must be owned by this workbook.
#### ```void xlnt::workbook::remove_sheet(worksheet worksheet)```
Removes the given worksheet from this workbook.
#### ```void xlnt::workbook::clear()```
Sets the contents of this workbook to be equivalent to that of a workbook returned by workbook::empty().
#### ```iterator xlnt::workbook::begin()```
Returns an iterator to the first worksheet in this workbook.
#### ```iterator xlnt::workbook::end()```
Returns an iterator to the worksheet following the last worksheet of the workbook. This worksheet acts as a placeholder; attempting to access it will cause an exception to be thrown.
#### ```const_iterator xlnt::workbook::begin() const```
Returns a const iterator to the first worksheet in this workbook.
#### ```const_iterator xlnt::workbook::end() const```
Returns a const iterator to the worksheet following the last worksheet of the workbook. This worksheet acts as a placeholder; attempting to access it will cause an exception to be thrown.
#### ```const_iterator xlnt::workbook::cbegin() const```
Returns an iterator to the first worksheet in this workbook.
#### ```const_iterator xlnt::workbook::cend() const```
Returns a const iterator to the worksheet following the last worksheet of the workbook. This worksheet acts as a placeholder; attempting to access it will cause an exception to be thrown.
#### ```void xlnt::workbook::apply_to_cells(std::function< void(cell)> f)```
Applies the function "f" to every non-empty cell in every worksheet in this workbook.
#### ```std::vector<std::string> xlnt::workbook::sheet_titles() const```
Returns a temporary vector containing the titles of each sheet in the order of the sheets in the workbook.
#### ```std::size_t xlnt::workbook::sheet_count() const```
Returns the number of sheets in this workbook.
#### ```bool xlnt::workbook::has_core_property(xlnt::core_property type) const```
Returns true if the workbook has the core property with the given name.
#### ```std::vector<xlnt::core_property> xlnt::workbook::core_properties() const```
Returns a vector of the type of each core property that is set to a particular value in this workbook.
#### ```variant xlnt::workbook::core_property(xlnt::core_property type) const```
Returns the value of the given core property.
#### ```void xlnt::workbook::core_property(xlnt::core_property type, const variant &value)```
Sets the given core property to the provided value.
#### ```bool xlnt::workbook::has_extended_property(xlnt::extended_property type) const```
Returns true if the workbook has the extended property with the given name.
#### ```std::vector<xlnt::extended_property> xlnt::workbook::extended_properties() const```
Returns a vector of the type of each extended property that is set to a particular value in this workbook.
#### ```variant xlnt::workbook::extended_property(xlnt::extended_property type) const```
Returns the value of the given extended property.
#### ```void xlnt::workbook::extended_property(xlnt::extended_property type, const variant &value)```
Sets the given extended property to the provided value.
#### ```bool xlnt::workbook::has_custom_property(const std::string &property_name) const```
Returns true if the workbook has the custom property with the given name.
#### ```std::vector<std::string> xlnt::workbook::custom_properties() const```
Returns a vector of the name of each custom property that is set to a particular value in this workbook.
#### ```variant xlnt::workbook::custom_property(const std::string &property_name) const```
Returns the value of the given custom property.
#### ```void xlnt::workbook::custom_property(const std::string &property_name, const variant &value)```
Creates a new custom property in this workbook and sets it to the provided value.
#### ```calendar xlnt::workbook::base_date() const```
Returns the base date used by this workbook. This will generally be windows_1900 except on Apple based systems when it will default to mac_1904 unless otherwise set via void workbook::base_date(calendar base_date).
#### ```void xlnt::workbook::base_date(calendar base_date)```
Sets the base date style of this workbook. This is the date and time that a numeric value of 0 represents.
#### ```bool xlnt::workbook::has_title() const```
Returns true if this workbook has had its title set.
#### ```std::string xlnt::workbook::title() const```
Returns the title of this workbook.
#### ```void xlnt::workbook::title(const std::string &title)```
Sets the title of this workbook to title.
#### ```std::vector<xlnt::named_range> xlnt::workbook::named_ranges() const```
Returns a vector of the named ranges in this workbook.
#### ```void xlnt::workbook::create_named_range(const std::string &name, worksheet worksheet, const range_reference &reference)```
Creates a new names range.
#### ```void xlnt::workbook::create_named_range(const std::string &name, worksheet worksheet, const std::string &reference_string)```
Creates a new names range.
#### ```bool xlnt::workbook::has_named_range(const std::string &name) const```
Returns true if a named range of the given name exists in the workbook.
#### ```class range xlnt::workbook::named_range(const std::string &name)```
Returns the named range with the given name.
#### ```void xlnt::workbook::remove_named_range(const std::string &name)```
Deletes the named range with the given name.
#### ```void xlnt::workbook::save(std::vector< std::uint8_t > &data) const```
Serializes the workbook into an XLSX file and saves the bytes into byte vector data.
#### ```void xlnt::workbook::save(std::vector< std::uint8_t > &data, const std::string &password) const```
Serializes the workbook into an XLSX file encrypted with the given password and saves the bytes into byte vector data.
#### ```void xlnt::workbook::save(const std::string &filename) const```
Serializes the workbook into an XLSX file and saves the data into a file named filename.
#### ```void xlnt::workbook::save(const std::string &filename, const std::string &password) const```
Serializes the workbook into an XLSX file encrypted with the given password and loads the bytes into a file named filename.
#### ```void xlnt::workbook::save(const xlnt::path &filename) const```
Serializes the workbook into an XLSX file and saves the data into a file named filename.
#### ```void xlnt::workbook::save(const xlnt::path &filename, const std::string &password) const```
Serializes the workbook into an XLSX file encrypted with the given password and loads the bytes into a file named filename.
#### ```void xlnt::workbook::save(std::ostream &stream) const```
Serializes the workbook into an XLSX file and saves the data into stream.
#### ```void xlnt::workbook::save(std::ostream &stream, const std::string &password) const```
Serializes the workbook into an XLSX file encrypted with the given password and loads the bytes into the given stream.
#### ```void xlnt::workbook::load(const std::vector< std::uint8_t > &data)```
Interprets byte vector data as an XLSX file and sets the content of this workbook to match that file.
#### ```void xlnt::workbook::load(const std::vector< std::uint8_t > &data, const std::string &password)```
Interprets byte vector data as an XLSX file encrypted with the given password and sets the content of this workbook to match that file.
#### ```void xlnt::workbook::load(const std::string &filename)```
Interprets file with the given filename as an XLSX file and sets the content of this workbook to match that file.
#### ```void xlnt::workbook::load(const std::string &filename, const std::string &password)```
Interprets file with the given filename as an XLSX file encrypted with the given password and sets the content of this workbook to match that file.
#### ```void xlnt::workbook::load(const xlnt::path &filename)```
Interprets file with the given filename as an XLSX file and sets the content of this workbook to match that file.
#### ```void xlnt::workbook::load(const xlnt::path &filename, const std::string &password)```
Interprets file with the given filename as an XLSX file encrypted with the given password and sets the content of this workbook to match that file.
#### ```void xlnt::workbook::load(std::istream &stream)```
Interprets data in stream as an XLSX file and sets the content of this workbook to match that file.
#### ```void xlnt::workbook::load(std::istream &stream, const std::string &password)```
Interprets data in stream as an XLSX file encrypted with the given password and sets the content of this workbook to match that file.
#### ```bool xlnt::workbook::has_view() const```
Returns true if this workbook has a view.
#### ```workbook_view xlnt::workbook::view() const```
Returns the view.
#### ```void xlnt::workbook::view(const workbook_view &view)```
Sets the view to view.
#### ```bool xlnt::workbook::has_code_name() const```
Returns true if a code name has been set for this workbook.
#### ```std::string xlnt::workbook::code_name() const```
Returns the code name that was set for this workbook.
#### ```void xlnt::workbook::code_name(const std::string &code_name)```
Sets the code name of this workbook to code_name.
#### ```bool xlnt::workbook::has_file_version() const```
Returns true if this workbook has a file version.
#### ```std::string xlnt::workbook::app_name() const```
Returns the AppName workbook file property.
#### ```std::size_t xlnt::workbook::last_edited() const```
Returns the LastEdited workbook file property.
#### ```std::size_t xlnt::workbook::lowest_edited() const```
Returns the LowestEdited workbook file property.
#### ```std::size_t xlnt::workbook::rup_build() const```
Returns the RupBuild workbook file property.
#### ```bool xlnt::workbook::has_theme() const```
Returns true if this workbook has a theme defined.
#### ```const xlnt::theme& xlnt::workbook::theme() const```
Returns a const reference to this workbook's theme.
#### ```void xlnt::workbook::theme(const class theme &value)```
Sets the theme to value.
#### ```xlnt::format xlnt::workbook::format(std::size_t format_index)```
Returns the cell format at the given index. The index is the position of the format in xl/styles.xml.
#### ```const xlnt::format xlnt::workbook::format(std::size_t format_index) const```
Returns the cell format at the given index. The index is the position of the format in xl/styles.xml.
#### ```xlnt::format xlnt::workbook::create_format(bool default_format=false)```
Creates a new format and returns it.
#### ```void xlnt::workbook::clear_formats()```
Clear all cell-level formatting and formats from the styelsheet. This leaves all other styling in place (e.g. named styles).
#### ```bool xlnt::workbook::has_style(const std::string &name) const```
Returns true if this workbook has a style with a name of name.
#### ```class style xlnt::workbook::style(const std::string &name)```
Returns the named style with the given name.
#### ```const class style xlnt::workbook::style(const std::string &name) const```
Returns the named style with the given name.
#### ```class style xlnt::workbook::create_style(const std::string &name)```
Creates a new style and returns it.
#### ```class style xlnt::workbook::create_builtin_style(std::size_t builtin_id)```
Creates a new style and returns it.
#### ```void xlnt::workbook::clear_styles()```
Clear all named styles from cells and remove the styles from from the styelsheet. This leaves all other styling in place (e.g. cell formats).
#### ```class manifest& xlnt::workbook::manifest()```
Returns a reference to the workbook's internal manifest.
#### ```const class manifest& xlnt::workbook::manifest() const```
Returns a reference to the workbook's internal manifest.
#### ```void xlnt::workbook::add_shared_string(const rich_text &shared, bool allow_duplicates=false)```
Append a shared string to the shared string collection in this workbook. This should not generally be called unless you know what you're doing. If allow_duplicates is false and the string is already in the collection, it will not be added.
#### ```std::vector<rich_text>& xlnt::workbook::shared_strings()```
Returns a reference to the shared strings being used by cells in this workbook.
#### ```const std::vector<rich_text>& xlnt::workbook::shared_strings() const```
Returns a reference to the shared strings being used by cells in this workbook.
#### ```void xlnt::workbook::thumbnail(const std::vector< std::uint8_t > &thumbnail, const std::string &extension, const std::string &content_type)```
Sets the workbook's thumbnail to the given vector of bytes, thumbnail, with the given extension (e.g. jpg) and content_type (e.g. image/jpeg).
#### ```const std::vector<std::uint8_t>& xlnt::workbook::thumbnail() const```
Returns a vector of bytes representing the workbook's thumbnail.
#### ```bool xlnt::workbook::has_calculation_properties() const```
Returns true if this workbook has any calculation properties set.
#### ```class calculation_properties xlnt::workbook::calculation_properties() const```
Returns the calculation properties used in this workbook.
#### ```void xlnt::workbook::calculation_properties(const class calculation_properties &props)```
Sets the calculation properties of this workbook to props.
#### ```workbook& xlnt::workbook::operator=(workbook other)```
Set the contents of this workbook to be equal to those of "other". Other is passed as value to allow for copy-swap idiom.
#### ```worksheet xlnt::workbook::operator[](const std::string &name)```
Return the worksheet with a title of "name".
#### ```worksheet xlnt::workbook::operator[](std::size_t index)```
Return the worksheet at "index".
#### ```bool xlnt::workbook::operator==(const workbook &rhs) const```
Return true if this workbook internal implementation points to the same memory as rhs's.
#### ```bool xlnt::workbook::operator!=(const workbook &rhs) const```
Return true if this workbook internal implementation doesn't point to the same memory as rhs's.
### workbook_view
#### ```bool xlnt::workbook_view::auto_filter_date_groupingundefined```
If true, dates will be grouped when presenting the user with filtering options.
#### ```bool xlnt::workbook_view::minimizedundefined```
If true, the view will be minimized.
#### ```bool xlnt::workbook_view::show_horizontal_scrollundefined```
If true, the horizontal scroll bar will be displayed.
#### ```bool xlnt::workbook_view::show_sheet_tabsundefined```
If true, the sheet tabs will be displayed.
#### ```bool xlnt::workbook_view::show_vertical_scrollundefined```
If true, the vertical scroll bar will be displayed.
#### ```bool xlnt::workbook_view::visibleundefined```
If true, the workbook window will be visible.
#### ```optional<std::size_t> xlnt::workbook_view::active_tabundefined```
The optional index to the active sheet in this view.
#### ```optional<std::size_t> xlnt::workbook_view::first_sheetundefined```
The optional index to the first sheet in this view.
#### ```optional<std::size_t> xlnt::workbook_view::tab_ratioundefined```
The optional ratio between the tabs bar and the horizontal scroll bar.
#### ```optional<std::size_t> xlnt::workbook_view::window_widthundefined```
The width of the workbook window in twips.
#### ```optional<std::size_t> xlnt::workbook_view::window_heightundefined```
The height of the workbook window in twips.
#### ```optional<std::size_t> xlnt::workbook_view::x_windowundefined```
The distance of the workbook window from the left side of the screen in twips.
#### ```optional<std::size_t> xlnt::workbook_view::y_windowundefined```
The distance of the workbook window from the top of the screen in twips.
### worksheet_iterator
#### ```xlnt::worksheet_iterator::worksheet_iterator(workbook &wb, std::size_t index)```
Constructs a worksheet iterator from a workbook and sheet index.
#### ```xlnt::worksheet_iterator::worksheet_iterator(const worksheet_iterator &)```
Copy constructs a worksheet iterator from another iterator.
#### ```worksheet_iterator& xlnt::worksheet_iterator::operator=(const worksheet_iterator &)```
Assigns the iterator so that it points to the same worksheet in the same workbook.
#### ```worksheet xlnt::worksheet_iterator::operator*()```
Dereferences the iterator to return the worksheet it is pointing to. If the iterator points to one-past-the-end of the workbook, an invalid_parameter exception will be thrown.
#### ```bool xlnt::worksheet_iterator::operator==(const worksheet_iterator &comparand) const```
Returns true if this iterator points to the same worksheet as comparand.
#### ```bool xlnt::worksheet_iterator::operator!=(const worksheet_iterator &comparand) const```
Returns true if this iterator doesn't point to the same worksheet as comparand.
#### ```worksheet_iterator xlnt::worksheet_iterator::operator++(int)```
Post-increment the iterator's internal workseet index. Returns a copy of the iterator as it was before being incremented.
#### ```worksheet_iterator& xlnt::worksheet_iterator::operator++()```
Pre-increment the iterator's internal workseet index. Returns a refernce to the same iterator.
### const_worksheet_iterator
#### ```xlnt::const_worksheet_iterator::const_worksheet_iterator(const workbook &wb, std::size_t index)```
Constructs a worksheet iterator from a workbook and sheet index.
#### ```xlnt::const_worksheet_iterator::const_worksheet_iterator(const const_worksheet_iterator &)```
Copy constructs a worksheet iterator from another iterator.
#### ```const_worksheet_iterator& xlnt::const_worksheet_iterator::operator=(const const_worksheet_iterator &)```
Assigns the iterator so that it points to the same worksheet in the same workbook.
#### ```const worksheet xlnt::const_worksheet_iterator::operator*()```
Dereferences the iterator to return the worksheet it is pointing to. If the iterator points to one-past-the-end of the workbook, an invalid_parameter exception will be thrown.
#### ```bool xlnt::const_worksheet_iterator::operator==(const const_worksheet_iterator &comparand) const```
Returns true if this iterator points to the same worksheet as comparand.
#### ```bool xlnt::const_worksheet_iterator::operator!=(const const_worksheet_iterator &comparand) const```
Returns true if this iterator doesn't point to the same worksheet as comparand.
#### ```const_worksheet_iterator xlnt::const_worksheet_iterator::operator++(int)```
Post-increment the iterator's internal workseet index. Returns a copy of the iterator as it was before being incremented.
#### ```const_worksheet_iterator& xlnt::const_worksheet_iterator::operator++()```
Pre-increment the iterator's internal workseet index. Returns a refernce to the same iterator.
## Worksheet Module
### cell_iterator
#### ```xlnt::cell_iterator::cell_iterator(worksheet ws, const cell_reference &start_cell, const range_reference &limits, major_order order, bool skip_null, bool wrap)```
Constructs a cell_iterator from a worksheet, range, and iteration settings.
#### ```xlnt::cell_iterator::cell_iterator(const cell_iterator &other)```
Constructs a cell_iterator as a copy of an existing cell_iterator.
#### ```cell_iterator& xlnt::cell_iterator::operator=(const cell_iterator &rhs)=default```
Assigns this iterator to match the data in rhs.
#### ```cell xlnt::cell_iterator::operator*()```
Dereferences this iterator to return the cell it points to.
#### ```bool xlnt::cell_iterator::operator==(const cell_iterator &other) const```
Returns true if this iterator is equivalent to other.
#### ```bool xlnt::cell_iterator::operator!=(const cell_iterator &other) const```
Returns true if this iterator isn't equivalent to other.
#### ```cell_iterator& xlnt::cell_iterator::operator--()```
Pre-decrements the iterator to point to the previous cell and returns a reference to the iterator.
#### ```cell_iterator xlnt::cell_iterator::operator--(int)```
Post-decrements the iterator to point to the previous cell and return a copy of the iterator before the decrement.
#### ```cell_iterator& xlnt::cell_iterator::operator++()```
Pre-increments the iterator to point to the previous cell and returns a reference to the iterator.
#### ```cell_iterator xlnt::cell_iterator::operator++(int)```
Post-increments the iterator to point to the previous cell and return a copy of the iterator before the decrement.
### const_cell_iterator
#### ```xlnt::const_cell_iterator::const_cell_iterator(worksheet ws, const cell_reference &start_cell, const range_reference &limits, major_order order, bool skip_null, bool wrap)```
Constructs a cell_iterator from a worksheet, range, and iteration settings.
#### ```xlnt::const_cell_iterator::const_cell_iterator(const const_cell_iterator &other)```
Constructs a cell_iterator as a copy of an existing cell_iterator.
#### ```const_cell_iterator& xlnt::const_cell_iterator::operator=(const const_cell_iterator &)=default```
Assigns this iterator to match the data in rhs.
#### ```const cell xlnt::const_cell_iterator::operator*() const```
Dereferences this iterator to return the cell it points to.
#### ```bool xlnt::const_cell_iterator::operator==(const const_cell_iterator &other) const```
Returns true if this iterator is equivalent to other.
#### ```bool xlnt::const_cell_iterator::operator!=(const const_cell_iterator &other) const```
Returns true if this iterator isn't equivalent to other.
#### ```const_cell_iterator& xlnt::const_cell_iterator::operator--()```
Pre-decrements the iterator to point to the previous cell and returns a reference to the iterator.
#### ```const_cell_iterator xlnt::const_cell_iterator::operator--(int)```
Post-decrements the iterator to point to the previous cell and return a copy of the iterator before the decrement.
#### ```const_cell_iterator& xlnt::const_cell_iterator::operator++()```
Pre-increments the iterator to point to the previous cell and returns a reference to the iterator.
#### ```const_cell_iterator xlnt::const_cell_iterator::operator++(int)```
Post-increments the iterator to point to the previous cell and return a copy of the iterator before the decrement.
### cell_vector
#### ```using xlnt::cell_vector::iterator = cell_iteratorundefined```
Iterate over cells in a cell_vector with an iterator of this type.
#### ```using xlnt::cell_vector::const_iterator = const_cell_iteratorundefined```
Iterate over const cells in a const cell_vector with an iterator of this type.
#### ```using xlnt::cell_vector::reverse_iterator = std::reverse_iterator<iterator>undefined```
Iterate over cells in a cell_vector in reverse oreder with an iterator of this type.
#### ```using xlnt::cell_vector::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined```
Iterate over const cells in a const cell_vector in reverse order with an iterator of this type.
#### ```xlnt::cell_vector::cell_vector(worksheet ws, const cell_reference &cursor, const range_reference &ref, major_order order, bool skip_null, bool wrap)```
Constructs a cell vector pointing to a given range in a given worksheet. order determines whether this vector is a row or a column. If skip_null is true, iterating over this vector will skip empty cells.
#### ```bool xlnt::cell_vector::empty() const```
Returns true if every cell in this vector is null (i.e. the cell doesn't exist in the worksheet).
#### ```cell xlnt::cell_vector::front()```
Returns the first cell in this vector.
#### ```const cell xlnt::cell_vector::front() const```
Returns the first cell in this vector.
#### ```cell xlnt::cell_vector::back()```
Returns the last cell in this vector.
#### ```const cell xlnt::cell_vector::back() const```
Returns the last cell in this vector.
#### ```std::size_t xlnt::cell_vector::length() const```
Returns the distance between the first and last cells in this vector.
#### ```iterator xlnt::cell_vector::begin()```
Returns an iterator to the first cell in this vector.
#### ```iterator xlnt::cell_vector::end()```
Returns an iterator to a cell one-past-the-end of this vector.
#### ```const_iterator xlnt::cell_vector::begin() const```
Returns an iterator to the first cell in this vector.
#### ```const_iterator xlnt::cell_vector::cbegin() const```
Returns an iterator to the first cell in this vector.
#### ```const_iterator xlnt::cell_vector::end() const```
Returns an iterator to a cell one-past-the-end of this vector.
#### ```const_iterator xlnt::cell_vector::cend() const```
Returns an iterator to a cell one-past-the-end of this vector.
#### ```reverse_iterator xlnt::cell_vector::rbegin()```
Returns a reverse iterator to the first cell of this reversed vector.
#### ```reverse_iterator xlnt::cell_vector::rend()```
Returns a reverse iterator to to a cell one-past-the-end of this reversed vector.
#### ```const_reverse_iterator xlnt::cell_vector::rbegin() const```
Returns a reverse iterator to the first cell of this reversed vector.
#### ```const_reverse_iterator xlnt::cell_vector::rend() const```
Returns a reverse iterator to to a cell one-past-the-end of this reversed vector.
#### ```const_reverse_iterator xlnt::cell_vector::crbegin() const```
Returns a reverse iterator to the first cell of this reversed vector.
#### ```const_reverse_iterator xlnt::cell_vector::crend() const```
Returns a reverse iterator to to a cell one-past-the-end of this reversed vector.
#### ```cell xlnt::cell_vector::operator[](std::size_t column_index)```
Returns the cell column_index distance away from the first cell in this vector.
#### ```const cell xlnt::cell_vector::operator[](std::size_t column_index) const```
Returns the cell column_index distance away from the first cell in this vector.
### column_properties
#### ```optional<double> xlnt::column_properties::widthundefined```
The optional width of the column
#### ```bool xlnt::column_properties::custom_widthundefined```
If true, this is a custom width
#### ```optional<std::size_t> xlnt::column_properties::styleundefined```
The style index of this column. This shouldn't be used since style indices aren't supposed to be used directly in xlnt. (TODO)
#### ```bool xlnt::column_properties::hiddenundefined```
If true, this column will be hidden
### header_footer
#### ```undefinedundefined```
Enumerates the three possible locations of a header or footer.
#### ```bool xlnt::header_footer::has_header() const```
True if any text has been added for a header at any location on any page.
#### ```bool xlnt::header_footer::has_footer() const```
True if any text has been added for a footer at any location on any page.
#### ```bool xlnt::header_footer::align_with_margins() const```
True if headers and footers should align to the page margins.
#### ```header_footer& xlnt::header_footer::align_with_margins(bool align)```
Set to true if headers and footers should align to the page margins. Set to false if headers and footers should align to the edge of the page.
#### ```bool xlnt::header_footer::different_odd_even() const```
True if headers and footers differ based on page number.
#### ```bool xlnt::header_footer::different_first() const```
True if headers and footers are different on the first page.
#### ```bool xlnt::header_footer::scale_with_doc() const```
True if headers and footers should scale to match the worksheet.
#### ```header_footer& xlnt::header_footer::scale_with_doc(bool scale)```
Set to true if headers and footers should scale to match the worksheet.
#### ```bool xlnt::header_footer::has_header(location where) const```
True if any text has been added at the given location on any page.
#### ```void xlnt::header_footer::clear_header()```
Remove all headers from all pages.
#### ```void xlnt::header_footer::clear_header(location where)```
Remove header at the given location on any page.
#### ```header_footer& xlnt::header_footer::header(location where, const std::string &text)```
Add a header at the given location with the given text.
#### ```header_footer& xlnt::header_footer::header(location where, const rich_text &text)```
Add a header at the given location with the given text.
#### ```rich_text xlnt::header_footer::header(location where) const```
Get the text of the header at the given location. If headers are different on odd and even pages, the odd header will be returned.
#### ```bool xlnt::header_footer::has_first_page_header() const```
True if a header has been set for the first page at any location.
#### ```bool xlnt::header_footer::has_first_page_header(location where) const```
True if a header has been set for the first page at the given location.
#### ```void xlnt::header_footer::clear_first_page_header()```
Remove all headers from the first page.
#### ```void xlnt::header_footer::clear_first_page_header(location where)```
Remove header from the first page at the given location.
#### ```header_footer& xlnt::header_footer::first_page_header(location where, const rich_text &text)```
Add a header on the first page at the given location with the given text.
#### ```rich_text xlnt::header_footer::first_page_header(location where) const```
Get the text of the first page header at the given location. If no first page header has been set, the general header for that location will be returned.
#### ```bool xlnt::header_footer::has_odd_even_header() const```
True if different headers have been set for odd and even pages.
#### ```bool xlnt::header_footer::has_odd_even_header(location where) const```
True if different headers have been set for odd and even pages at the given location.
#### ```void xlnt::header_footer::clear_odd_even_header()```
Remove odd/even headers at all locations.
#### ```void xlnt::header_footer::clear_odd_even_header(location where)```
Remove odd/even headers at the given location.
#### ```header_footer& xlnt::header_footer::odd_even_header(location where, const rich_text &odd, const rich_text &even)```
Add a header for odd pages at the given location with the given text.
#### ```rich_text xlnt::header_footer::odd_header(location where) const```
Get the text of the odd page header at the given location. If no odd page header has been set, the general header for that location will be returned.
#### ```rich_text xlnt::header_footer::even_header(location where) const```
Get the text of the even page header at the given location. If no even page header has been set, the general header for that location will be returned.
#### ```bool xlnt::header_footer::has_footer(location where) const```
True if any text has been added at the given location on any page.
#### ```void xlnt::header_footer::clear_footer()```
Remove all footers from all pages.
#### ```void xlnt::header_footer::clear_footer(location where)```
Remove footer at the given location on any page.
#### ```header_footer& xlnt::header_footer::footer(location where, const std::string &text)```
Add a footer at the given location with the given text.
#### ```header_footer& xlnt::header_footer::footer(location where, const rich_text &text)```
Add a footer at the given location with the given text.
#### ```rich_text xlnt::header_footer::footer(location where) const```
Get the text of the footer at the given location. If footers are different on odd and even pages, the odd footer will be returned.
#### ```bool xlnt::header_footer::has_first_page_footer() const```
True if a footer has been set for the first page at any location.
#### ```bool xlnt::header_footer::has_first_page_footer(location where) const```
True if a footer has been set for the first page at the given location.
#### ```void xlnt::header_footer::clear_first_page_footer()```
Remove all footers from the first page.
#### ```void xlnt::header_footer::clear_first_page_footer(location where)```
Remove footer from the first page at the given location.
#### ```header_footer& xlnt::header_footer::first_page_footer(location where, const rich_text &text)```
Add a footer on the first page at the given location with the given text.
#### ```rich_text xlnt::header_footer::first_page_footer(location where) const```
Get the text of the first page footer at the given location. If no first page footer has been set, the general footer for that location will be returned.
#### ```bool xlnt::header_footer::has_odd_even_footer() const```
True if different footers have been set for odd and even pages.
#### ```bool xlnt::header_footer::has_odd_even_footer(location where) const```
True if different footers have been set for odd and even pages at the given location.
#### ```void xlnt::header_footer::clear_odd_even_footer()```
Remove odd/even footers at all locations.
#### ```void xlnt::header_footer::clear_odd_even_footer(location where)```
Remove odd/even footers at the given location.
#### ```header_footer& xlnt::header_footer::odd_even_footer(location where, const rich_text &odd, const rich_text &even)```
Add a footer for odd pages at the given location with the given text.
#### ```rich_text xlnt::header_footer::odd_footer(location where) const```
Get the text of the odd page footer at the given location. If no odd page footer has been set, the general footer for that location will be returned.
#### ```rich_text xlnt::header_footer::even_footer(location where) const```
Get the text of the even page footer at the given location. If no even page footer has been set, the general footer for that location will be returned.
### page_margins
#### ```xlnt::page_margins::page_margins()```
Constructs a page margins objects with Excel-default margins.
#### ```double xlnt::page_margins::top() const```
Returns the top margin
#### ```void xlnt::page_margins::top(double top)```
Sets the top margin to top
#### ```double xlnt::page_margins::left() const```
Returns the left margin
#### ```void xlnt::page_margins::left(double left)```
Sets the left margin to left
#### ```double xlnt::page_margins::bottom() const```
Returns the bottom margin
#### ```void xlnt::page_margins::bottom(double bottom)```
Sets the bottom margin to bottom
#### ```double xlnt::page_margins::right() const```
Returns the right margin
#### ```void xlnt::page_margins::right(double right)```
Sets the right margin to right
#### ```double xlnt::page_margins::header() const```
Returns the header margin
#### ```void xlnt::page_margins::header(double header)```
Sets the header margin to header
#### ```double xlnt::page_margins::footer() const```
Returns the footer margin
#### ```void xlnt::page_margins::footer(double footer)```
Sets the footer margin to footer
### page_setup
#### ```xlnt::page_setup::page_setup()```
Default constructor.
#### ```xlnt::page_break xlnt::page_setup::page_break() const```
Returns the page break.
#### ```void xlnt::page_setup::page_break(xlnt::page_break b)```
Sets the page break to b.
#### ```xlnt::sheet_state xlnt::page_setup::sheet_state() const```
Returns the current sheet state of this page setup.
#### ```void xlnt::page_setup::sheet_state(xlnt::sheet_state sheet_state)```
Sets the sheet state to sheet_state.
#### ```xlnt::paper_size xlnt::page_setup::paper_size() const```
Returns the paper size which should be used to print the worksheet using this page setup.
#### ```void xlnt::page_setup::paper_size(xlnt::paper_size paper_size)```
Sets the paper size of this page setup.
#### ```xlnt::orientation xlnt::page_setup::orientation() const```
Returns the orientation of the worksheet using this page setup.
#### ```void xlnt::page_setup::orientation(xlnt::orientation orientation)```
Sets the orientation of the page.
#### ```bool xlnt::page_setup::fit_to_page() const```
Returns true if this worksheet should be scaled to fit on a single page during printing.
#### ```void xlnt::page_setup::fit_to_page(bool fit_to_page)```
If true, forces the worksheet to be scaled to fit on a single page during printing.
#### ```bool xlnt::page_setup::fit_to_height() const```
Returns true if the height of this worksheet should be scaled to fit on a printed page.
#### ```void xlnt::page_setup::fit_to_height(bool fit_to_height)```
Sets whether the height of the page should be scaled to fit on a printed page.
#### ```bool xlnt::page_setup::fit_to_width() const```
Returns true if the width of this worksheet should be scaled to fit on a printed page.
#### ```void xlnt::page_setup::fit_to_width(bool fit_to_width)```
Sets whether the width of the page should be scaled to fit on a printed page.
#### ```void xlnt::page_setup::horizontal_centered(bool horizontal_centered)```
Sets whether the worksheet should be centered horizontall on the page if it takes up less than a full page.
#### ```bool xlnt::page_setup::horizontal_centered() const```
Returns whether horizontal centering has been enabled.
#### ```void xlnt::page_setup::vertical_centered(bool vertical_centered)```
Sets whether the worksheet should be vertically centered on the page if it takes up less than a full page.
#### ```bool xlnt::page_setup::vertical_centered() const```
Returns whether vertical centering has been enabled.
#### ```void xlnt::page_setup::scale(double scale)```
Sets the factor by which the page should be scaled during printing.
#### ```double xlnt::page_setup::scale() const```
Returns the factor by which the page should be scaled during printing.
### pane
#### ```optional<cell_reference> xlnt::pane::top_left_cellundefined```
The optional top left cell
#### ```pane_state xlnt::pane::stateundefined```
The state of the pane
#### ```pane_corner xlnt::pane::active_paneundefined```
The pane which contains the active cell
#### ```row_t xlnt::pane::y_splitundefined```
The row where the split should take place
#### ```column_t xlnt::pane::x_splitundefined```
The column where the split should take place
#### ```bool xlnt::pane::operator==(const pane &rhs) const```
Returns true if this pane is equal to rhs based on its top-left cell, state, active pane, and x/y split location.
### range
#### ```using xlnt::range::iterator = range_iteratorundefined```
Alias for the iterator type
#### ```using xlnt::range::const_iterator = const_range_iteratorundefined```
Alias for the const iterator type
#### ```using xlnt::range::reverse_iterator = std::reverse_iterator<iterator>undefined```
Alias for the reverse iterator type
#### ```using xlnt::range::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined```
Alias for the const reverse iterator type
#### ```xlnt::range::range(worksheet ws, const range_reference &reference, major_order order=major_order::row, bool skip_null=false)```
Constructs a range on the given worksheet.
#### ```xlnt::range::~range()```
Desctructor
#### ```xlnt::range::range(const range &)=default```
Default copy constructor.
#### ```cell_vector xlnt::range::vector(std::size_t n)```
Returns a vector pointing to the n-th row or column in this range (depending on major order).
#### ```const cell_vector xlnt::range::vector(std::size_t n) const```
Returns a vector pointing to the n-th row or column in this range (depending on major order).
#### ```class cell xlnt::range::cell(const cell_reference &ref)```
Returns a cell in the range relative to its top left cell.
#### ```const class cell xlnt::range::cell(const cell_reference &ref) const```
Returns a cell in the range relative to its top left cell.
#### ```range_reference xlnt::range::reference() const```
Returns the reference defining the bounds of this range.
#### ```std::size_t xlnt::range::length() const```
Returns the number of rows or columns in this range (depending on major order).
#### ```bool xlnt::range::contains(const cell_reference &ref)```
Returns true if the given cell exists in the parent worksheet of this range.
#### ```range xlnt::range::alignment(const xlnt::alignment &new_alignment)```
Sets the alignment of all cells in the range to new_alignment and returns the range.
#### ```range xlnt::range::border(const xlnt::border &new_border)```
Sets the border of all cells in the range to new_border and returns the range.
#### ```range xlnt::range::fill(const xlnt::fill &new_fill)```
Sets the fill of all cells in the range to new_fill and returns the range.
#### ```range xlnt::range::font(const xlnt::font &new_font)```
Sets the font of all cells in the range to new_font and returns the range.
#### ```range xlnt::range::number_format(const xlnt::number_format &new_number_format)```
Sets the number format of all cells in the range to new_number_format and returns the range.
#### ```range xlnt::range::protection(const xlnt::protection &new_protection)```
Sets the protection of all cells in the range to new_protection and returns the range.
#### ```range xlnt::range::style(const class style &new_style)```
Sets the named style applied to all cells in this range to a style named style_name.
#### ```range xlnt::range::style(const std::string &style_name)```
Sets the named style applied to all cells in this range to a style named style_name. If this style has not been previously created in the workbook, a key_not_found exception will be thrown.
#### ```cell_vector xlnt::range::front()```
Returns the first row or column in this range.
#### ```const cell_vector xlnt::range::front() const```
Returns the first row or column in this range.
#### ```cell_vector xlnt::range::back()```
Returns the last row or column in this range.
#### ```const cell_vector xlnt::range::back() const```
Returns the last row or column in this range.
#### ```iterator xlnt::range::begin()```
Returns an iterator to the first row or column in this range.
#### ```iterator xlnt::range::end()```
Returns an iterator to one past the last row or column in this range.
#### ```const_iterator xlnt::range::begin() const```
Returns an iterator to the first row or column in this range.
#### ```const_iterator xlnt::range::end() const```
Returns an iterator to one past the last row or column in this range.
#### ```const_iterator xlnt::range::cbegin() const```
Returns an iterator to the first row or column in this range.
#### ```const_iterator xlnt::range::cend() const```
Returns an iterator to one past the last row or column in this range.
#### ```reverse_iterator xlnt::range::rbegin()```
Returns a reverse iterator to the first row or column in this range.
#### ```reverse_iterator xlnt::range::rend()```
Returns a reverse iterator to one past the last row or column in this range.
#### ```const_reverse_iterator xlnt::range::rbegin() const```
Returns a reverse iterator to the first row or column in this range.
#### ```const_reverse_iterator xlnt::range::rend() const```
Returns a reverse iterator to one past the last row or column in this range.
#### ```const_reverse_iterator xlnt::range::crbegin() const```
Returns a reverse iterator to the first row or column in this range.
#### ```const_reverse_iterator xlnt::range::crend() const```
Returns a reverse iterator to one past the last row or column in this range.
#### ```void xlnt::range::apply(std::function< void(class cell)> f)```
Applies function f to all cells in the range
#### ```cell_vector xlnt::range::operator[](std::size_t n)```
Returns the n-th row or column in this range.
#### ```const cell_vector xlnt::range::operator[](std::size_t n) const```
Returns the n-th row or column in this range.
#### ```bool xlnt::range::operator==(const range &comparand) const```
Returns true if this range is equivalent to comparand.
#### ```bool xlnt::range::operator!=(const range &comparand) const```
Returns true if this range is not equivalent to comparand.
### range_iterator
#### ```xlnt::range_iterator::range_iterator(worksheet &ws, const cell_reference &cursor, const range_reference &bounds, major_order order, bool skip_null)```
Constructs a range iterator on a worksheet, cell pointing to the current row or column, range bounds, an order, and whether or not to skip null column/rows.
#### ```xlnt::range_iterator::range_iterator(const range_iterator &other)```
Copy constructor.
#### ```cell_vector xlnt::range_iterator::operator*() const```
Dereference the iterator to return a column or row.
#### ```range_iterator& xlnt::range_iterator::operator=(const range_iterator &)=default```
Default assignment operator.
#### ```bool xlnt::range_iterator::operator==(const range_iterator &other) const```
Returns true if this iterator is equivalent to other.
#### ```bool xlnt::range_iterator::operator!=(const range_iterator &other) const```
Returns true if this iterator is not equivalent to other.
#### ```range_iterator& xlnt::range_iterator::operator--()```
Pre-decrement the iterator to point to the previous row/column.
#### ```range_iterator xlnt::range_iterator::operator--(int)```
Post-decrement the iterator to point to the previous row/column.
#### ```range_iterator& xlnt::range_iterator::operator++()```
Pre-increment the iterator to point to the next row/column.
#### ```range_iterator xlnt::range_iterator::operator++(int)```
Post-increment the iterator to point to the next row/column.
### const_range_iterator
#### ```xlnt::const_range_iterator::const_range_iterator(const worksheet &ws, const cell_reference &cursor, const range_reference &bounds, major_order order, bool skip_null)```
Constructs a range iterator on a worksheet, cell pointing to the current row or column, range bounds, an order, and whether or not to skip null column/rows.
#### ```xlnt::const_range_iterator::const_range_iterator(const const_range_iterator &other)```
Copy constructor.
#### ```const cell_vector xlnt::const_range_iterator::operator*() const```
Dereferennce the iterator to return the current column/row.
#### ```const_range_iterator& xlnt::const_range_iterator::operator=(const const_range_iterator &)=default```
Default assignment operator.
#### ```bool xlnt::const_range_iterator::operator==(const const_range_iterator &other) const```
Returns true if this iterator is equivalent to other.
#### ```bool xlnt::const_range_iterator::operator!=(const const_range_iterator &other) const```
Returns true if this iterator is not equivalent to other.
#### ```const_range_iterator& xlnt::const_range_iterator::operator--()```
Pre-decrement the iterator to point to the next row/column.
#### ```const_range_iterator xlnt::const_range_iterator::operator--(int)```
Post-decrement the iterator to point to the next row/column.
#### ```const_range_iterator& xlnt::const_range_iterator::operator++()```
Pre-increment the iterator to point to the next row/column.
#### ```const_range_iterator xlnt::const_range_iterator::operator++(int)```
Post-increment the iterator to point to the next row/column.
### range_reference
#### ```static range_reference xlnt::range_reference::make_absolute(const range_reference &relative_reference)```
Converts relative reference coordinates to absolute coordinates (B12 -> $B$12)
#### ```xlnt::range_reference::range_reference()```
Constructs a range reference equal to A1:A1
#### ```xlnt::range_reference::range_reference(const std::string &range_string)```
Constructs a range reference equivalent to the provided range_string in the form top_left:bottom_right.
#### ```xlnt::range_reference::range_reference(const char *range_string)```
Constructs a range reference equivalent to the provided range_string in the form top_left:bottom_right.
#### ```xlnt::range_reference::range_reference(const std::pair< cell_reference, cell_reference > &reference_pair)```
Constructs a range reference from a pair of cell references.
#### ```xlnt::range_reference::range_reference(const cell_reference &start, const cell_reference &end)```
Constructs a range reference from cell references indicating top left and bottom right coordinates of the range.
#### ```xlnt::range_reference::range_reference(column_t column_index_start, row_t row_index_start, column_t column_index_end, row_t row_index_end)```
Constructs a range reference from column and row indices.
#### ```bool xlnt::range_reference::is_single_cell() const```
Returns true if the range has a width and height of 1 cell.
#### ```std::size_t xlnt::range_reference::width() const```
Returns the number of columns encompassed by this range.
#### ```std::size_t xlnt::range_reference::height() const```
Returns the number of rows encompassed by this range.
#### ```cell_reference xlnt::range_reference::top_left() const```
Returns the coordinate of the top left cell of this range.
#### ```cell_reference xlnt::range_reference::top_right() const```
Returns the coordinate of the top right cell of this range.
#### ```cell_reference xlnt::range_reference::bottom_left() const```
Returns the coordinate of the bottom left cell of this range.
#### ```cell_reference xlnt::range_reference::bottom_right() const```
Returns the coordinate of the bottom right cell of this range.
#### ```range_reference xlnt::range_reference::make_offset(int column_offset, int row_offset) const```
Returns a new range reference with the same width and height as this range but shifted by the given number of columns and rows.
#### ```std::string xlnt::range_reference::to_string() const```
Returns a string representation of this range.
#### ```bool xlnt::range_reference::operator==(const range_reference &comparand) const```
Returns true if this range is equivalent to the other range.
#### ```bool xlnt::range_reference::operator==(const std::string &reference_string) const```
Returns true if this range is equivalent to the string representation of the other range.
#### ```bool xlnt::range_reference::operator==(const char *reference_string) const```
Returns true if this range is equivalent to the string representation of the other range.
#### ```bool xlnt::range_reference::operator!=(const range_reference &comparand) const```
Returns true if this range is not equivalent to the other range.
#### ```bool xlnt::range_reference::operator!=(const std::string &reference_string) const```
Returns true if this range is not equivalent to the string representation of the other range.
#### ```bool xlnt::range_reference::operator!=(const char *reference_string) const```
Returns true if this range is not equivalent to the string representation of the other range.
### row_properties
#### ```optional<double> xlnt::row_properties::heightundefined```
Optional height
#### ```bool xlnt::row_properties::custom_heightundefined```
Whether or not the height is different from the default
#### ```bool xlnt::row_properties::hiddenundefined```
Whether or not the row should be hidden
#### ```optional<std::size_t> xlnt::row_properties::styleundefined```
The index to the style used by all cells in this row
### selection
#### ```bool xlnt::selection::has_active_cell() const```
Returns true if this selection has a defined active cell.
#### ```cell_reference xlnt::selection::active_cell() const```
Returns the cell reference of the active cell.
#### ```void xlnt::selection::active_cell(const cell_reference &ref)```
Sets the active cell to that pointed to by ref.
#### ```range_reference xlnt::selection::sqref() const```
Returns the range encompassed by this selection.
#### ```pane_corner xlnt::selection::pane() const```
Returns the sheet quadrant of this selection.
#### ```void xlnt::selection::pane(pane_corner corner)```
Sets the sheet quadrant of this selection to corner.
#### ```bool xlnt::selection::operator==(const selection &rhs) const```
Returns true if this selection is equal to rhs based on its active cell, sqref, and pane.
### sheet_protection
#### ```static std::string xlnt::sheet_protection::hash_password(const std::string &password)```
Calculates and returns the hash of the given protection password.
#### ```void xlnt::sheet_protection::password(const std::string &password)```
Sets the protection password to password.
#### ```std::string xlnt::sheet_protection::hashed_password() const```
Returns the hash of the password set for this sheet protection.
### sheet_view
#### ```void xlnt::sheet_view::id(std::size_t new_id)```
Sets the ID of this view to new_id.
#### ```std::size_t xlnt::sheet_view::id() const```
Returns the ID of this view.
#### ```bool xlnt::sheet_view::has_pane() const```
Returns true if this view has a pane defined.
#### ```struct pane& xlnt::sheet_view::pane()```
Returns a reference to this view's pane.
#### ```const struct pane& xlnt::sheet_view::pane() const```
Returns a reference to this view's pane.
#### ```void xlnt::sheet_view::clear_pane()```
Removes the defined pane from this view.
#### ```void xlnt::sheet_view::pane(const struct pane &new_pane)```
Sets the pane of this view to new_pane.
#### ```bool xlnt::sheet_view::has_selections() const```
Returns true if this view has any selections.
#### ```void xlnt::sheet_view::add_selection(const class selection &new_selection)```
Adds the given selection to the collection of selections.
#### ```void xlnt::sheet_view::clear_selections()```
Removes all selections.
#### ```std::vector<xlnt::selection> xlnt::sheet_view::selections() const```
Returns the collection of selections as a vector.
#### ```class xlnt::selection& xlnt::sheet_view::selection(std::size_t index)```
Returns the selection at the given index.
#### ```void xlnt::sheet_view::show_grid_lines(bool show)```
If show is true, grid lines will be shown for sheets using this view.
#### ```bool xlnt::sheet_view::show_grid_lines() const```
Returns true if grid lines will be shown for sheets using this view.
#### ```void xlnt::sheet_view::default_grid_color(bool is_default)```
If is_default is true, the default grid color will be used.
#### ```bool xlnt::sheet_view::default_grid_color() const```
Returns true if the default grid color will be used.
#### ```void xlnt::sheet_view::type(sheet_view_type new_type)```
Sets the type of this view.
#### ```sheet_view_type xlnt::sheet_view::type() const```
Returns the type of this view.
#### ```bool xlnt::sheet_view::operator==(const sheet_view &rhs) const```
Returns true if this view is requal to rhs based on its id, grid lines setting, default grid color, pane, and selections.
### worksheet
#### ```using xlnt::worksheet::iterator = range_iteratorundefined```
Iterate over a non-const worksheet with an iterator of this type.
#### ```using xlnt::worksheet::const_iterator = const_range_iteratorundefined```
Iterate over a non-const worksheet with an iterator of this type.
#### ```using xlnt::worksheet::reverse_iterator = std::reverse_iterator<iterator>undefined```
Iterate in reverse over a non-const worksheet with an iterator of this type.
#### ```using xlnt::worksheet::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined```
Iterate in reverse order over a const worksheet with an iterator of this type.
#### ```friend class detail::xlsx_consumerundefined```
#### ```friend class detail::xlsx_producerundefined```
#### ```xlnt::worksheet::worksheet()```
Construct a null worksheet. No methods should be called on such a worksheet.
#### ```xlnt::worksheet::worksheet(const worksheet &rhs)```
Copy constructor. This worksheet will point to the same memory as rhs's worksheet.
#### ```class workbook& xlnt::worksheet::workbook()```
Returns a reference to the workbook this worksheet is owned by.
#### ```const class workbook& xlnt::worksheet::workbook() const```
Returns a reference to the workbook this worksheet is owned by.
#### ```void xlnt::worksheet::garbage_collect()```
Deletes data held in the worksheet that does not affect the internal data or display. For example, unreference styles and empty cells will be removed.
#### ```std::size_t xlnt::worksheet::id() const```
Returns the unique numeric identifier of this worksheet. This will sometimes but not necessarily be the index of the worksheet in the workbook.
#### ```void xlnt::worksheet::id(std::size_t id)```
Set the unique numeric identifier. The id defaults to the lowest unused id in the workbook so this should not be called without a good reason.
#### ```std::string xlnt::worksheet::title() const```
Returns the title of this sheet.
#### ```void xlnt::worksheet::title(const std::string &title)```
Sets the title of this sheet.
#### ```cell_reference xlnt::worksheet::frozen_panes() const```
Returns the top left corner of the region above and to the left of which panes are frozen.
#### ```void xlnt::worksheet::freeze_panes(cell top_left_cell)```
Freeze panes above and to the left of top_left_cell.
#### ```void xlnt::worksheet::freeze_panes(const cell_reference &top_left_coordinate)```
Freeze panes above and to the left of top_left_coordinate.
#### ```void xlnt::worksheet::unfreeze_panes()```
Remove frozen panes. The data in those panes will be unaffectedthis affects only the view.
#### ```bool xlnt::worksheet::has_frozen_panes() const```
Returns true if this sheet has a frozen row, frozen column, or both.
#### ```bool xlnt::worksheet::has_cell(const cell_reference &reference) const```
Returns true if this sheet has an initialized cell at the given reference.
#### ```class cell xlnt::worksheet::cell(const cell_reference &reference)```
Returns the cell at the given reference. If the cell doesn't exist, it will be initialized to null before being returned.
#### ```const class cell xlnt::worksheet::cell(const cell_reference &reference) const```
Returns the cell at the given reference. If the cell doesn't exist, an invalid_parameter exception will be thrown.
#### ```class cell xlnt::worksheet::cell(column_t column, row_t row)```
Returns the cell at the given column and row. If the cell doesn't exist, it will be initialized to null before being returned.
#### ```const class cell xlnt::worksheet::cell(column_t column, row_t row) const```
Returns the cell at the given column and row. If the cell doesn't exist, an invalid_parameter exception will be thrown.
#### ```class range xlnt::worksheet::range(const std::string &reference_string)```
Returns the range defined by reference string. If reference string is the name of a previously-defined named range in the sheet, it will be returned.
#### ```const class range xlnt::worksheet::range(const std::string &reference_string) const```
Returns the range defined by reference string. If reference string is the name of a previously-defined named range in the sheet, it will be returned.
#### ```class range xlnt::worksheet::range(const range_reference &reference)```
Returns the range defined by reference.
#### ```const class range xlnt::worksheet::range(const range_reference &reference) const```
Returns the range defined by reference.
#### ```class range xlnt::worksheet::rows(bool skip_null=true)```
Returns a range encompassing all cells in this sheet which will be iterated upon in row-major order. If skip_null is true (default), empty rows and cells will be skipped during iteration of the range.
#### ```const class range xlnt::worksheet::rows(bool skip_null=true) const```
Returns a range encompassing all cells in this sheet which will be iterated upon in row-major order. If skip_null is true (default), empty rows and cells will be skipped during iteration of the range.
#### ```class range xlnt::worksheet::columns(bool skip_null=true)```
Returns a range ecompassing all cells in this sheet which will be iterated upon in column-major order. If skip_null is true (default), empty columns and cells will be skipped during iteration of the range.
#### ```const class range xlnt::worksheet::columns(bool skip_null=true) const```
Returns a range ecompassing all cells in this sheet which will be iterated upon in column-major order. If skip_null is true (default), empty columns and cells will be skipped during iteration of the range.
#### ```xlnt::column_properties& xlnt::worksheet::column_properties(column_t column)```
Returns the column properties for the given column.
#### ```const xlnt::column_properties& xlnt::worksheet::column_properties(column_t column) const```
Returns the column properties for the given column.
#### ```bool xlnt::worksheet::has_column_properties(column_t column) const```
Returns true if column properties have been set for the given column.
#### ```void xlnt::worksheet::add_column_properties(column_t column, const class column_properties &props)```
Sets column properties for the given column to props.
#### ```double xlnt::worksheet::column_width(column_t column) const```
Calculates the width of the given column. This will be the default column width if a custom width is not set on this column's column_properties.
#### ```xlnt::row_properties& xlnt::worksheet::row_properties(row_t row)```
Returns the row properties for the given row.
#### ```const xlnt::row_properties& xlnt::worksheet::row_properties(row_t row) const```
Returns the row properties for the given row.
#### ```bool xlnt::worksheet::has_row_properties(row_t row) const```
Returns true if row properties have been set for the given row.
#### ```void xlnt::worksheet::add_row_properties(row_t row, const class row_properties &props)```
Sets row properties for the given row to props.
#### ```double xlnt::worksheet::row_height(row_t row) const```
Calculate the height of the given row. This will be the default row height if a custom height is not set on this row's row_properties.
#### ```cell_reference xlnt::worksheet::point_pos(int left, int top) const```
Returns a reference to the cell at the given point coordinates.
#### ```void xlnt::worksheet::create_named_range(const std::string &name, const std::string &reference_string)```
Creates a new named range with the given name encompassing the string representing a range.
#### ```void xlnt::worksheet::create_named_range(const std::string &name, const range_reference &reference)```
Creates a new named range with the given name encompassing the given range reference.
#### ```bool xlnt::worksheet::has_named_range(const std::string &name) const```
Returns true if this worksheet contains a named range with the given name.
#### ```class range xlnt::worksheet::named_range(const std::string &name)```
Returns the named range with the given name. Throws key_not_found exception if the named range doesn't exist.
#### ```const class range xlnt::worksheet::named_range(const std::string &name) const```
Returns the named range with the given name. Throws key_not_found exception if the named range doesn't exist.
#### ```void xlnt::worksheet::remove_named_range(const std::string &name)```
Removes a named range with the given name.
#### ```row_t xlnt::worksheet::lowest_row() const```
Returns the row of the first non-empty cell in the worksheet.
#### ```row_t xlnt::worksheet::highest_row() const```
Returns the row of the last non-empty cell in the worksheet.
#### ```row_t xlnt::worksheet::next_row() const```
Returns the row directly below the last non-empty cell in the worksheet.
#### ```column_t xlnt::worksheet::lowest_column() const```
Returns the column of the first non-empty cell in the worksheet.
#### ```column_t xlnt::worksheet::highest_column() const```
Returns the column of the last non-empty cell in the worksheet.
#### ```range_reference xlnt::worksheet::calculate_dimension() const```
Returns a range_reference pointing to the full range of non-empty cells in the worksheet.
#### ```void xlnt::worksheet::merge_cells(const std::string &reference_string)```
Merges the cells within the range represented by the given string.
#### ```void xlnt::worksheet::merge_cells(const range_reference &reference)```
Merges the cells within the given range.
#### ```void xlnt::worksheet::unmerge_cells(const std::string &reference_string)```
Removes the merging of the cells in the range represented by the given string.
#### ```void xlnt::worksheet::unmerge_cells(const range_reference &reference)```
Removes the merging of the cells in the given range.
#### ```std::vector<range_reference> xlnt::worksheet::merged_ranges() const```
Returns a vector of references of all merged ranges in the worksheet.
#### ```bool xlnt::worksheet::operator==(const worksheet &other) const```
Returns true if this worksheet refers to the same worksheet as other.
#### ```bool xlnt::worksheet::operator!=(const worksheet &other) const```
Returns true if this worksheet doesn't refer to the same worksheet as other.
#### ```bool xlnt::worksheet::operator==(std::nullptr_t) const```
Returns true if this worksheet is null.
#### ```bool xlnt::worksheet::operator!=(std::nullptr_t) const```
Returns true if this worksheet is not null.
#### ```void xlnt::worksheet::operator=(const worksheet &other)```
Sets the internal pointer of this worksheet object to point to other.
#### ```class cell xlnt::worksheet::operator[](const cell_reference &reference)```
Convenience method for worksheet::cell method.
#### ```const class cell xlnt::worksheet::operator[](const cell_reference &reference) const```
Convenience method for worksheet::cell method.
#### ```bool xlnt::worksheet::compare(const worksheet &other, bool reference) const```
Returns true if this worksheet is equal to other. If reference is true, the comparison will only check that both worksheets point to the same sheet in the same workbook.
#### ```bool xlnt::worksheet::has_page_setup() const```
Returns true if this worksheet has a page setup.
#### ```xlnt::page_setup xlnt::worksheet::page_setup() const```
Returns the page setup for this sheet.
#### ```void xlnt::worksheet::page_setup(const struct page_setup &setup)```
Sets the page setup for this sheet to setup.
#### ```bool xlnt::worksheet::has_page_margins() const```
Returns true if this page has margins.
#### ```xlnt::page_margins xlnt::worksheet::page_margins() const```
Returns the margins of this sheet.
#### ```void xlnt::worksheet::page_margins(const class page_margins &margins)```
Sets the margins of this sheet to margins.
#### ```range_reference xlnt::worksheet::auto_filter() const```
Returns the current auto-filter of this sheet.
#### ```void xlnt::worksheet::auto_filter(const std::string &range_string)```
Sets the auto-filter of this sheet to the range defined by range_string.
#### ```void xlnt::worksheet::auto_filter(const xlnt::range &range)```
Sets the auto-filter of this sheet to the given range.
#### ```void xlnt::worksheet::auto_filter(const range_reference &reference)```
Sets the auto-filter of this sheet to the range defined by reference.
#### ```void xlnt::worksheet::clear_auto_filter()```
Clear the auto-filter from this sheet.
#### ```bool xlnt::worksheet::has_auto_filter() const```
Returns true if this sheet has an auto-filter set.
#### ```void xlnt::worksheet::reserve(std::size_t n)```
Reserve n rows. This can be optionally called before adding many rows to improve performance.
#### ```bool xlnt::worksheet::has_header_footer() const```
Returns true if this sheet has a header/footer.
#### ```class header_footer xlnt::worksheet::header_footer() const```
Returns the header/footer of this sheet.
#### ```void xlnt::worksheet::header_footer(const class header_footer &new_header_footer)```
Sets the header/footer of this sheet to new_header_footer.
#### ```xlnt::sheet_state xlnt::worksheet::sheet_state() const```
Returns the sheet state of this sheet.
#### ```void xlnt::worksheet::sheet_state(xlnt::sheet_state state)```
Sets the sheet state of this sheet.
#### ```iterator xlnt::worksheet::begin()```
Returns an iterator to the first row in this sheet.
#### ```iterator xlnt::worksheet::end()```
Returns an iterator one past the last row in this sheet.
#### ```const_iterator xlnt::worksheet::begin() const```
Return a constant iterator to the first row in this sheet.
#### ```const_iterator xlnt::worksheet::end() const```
Returns a constant iterator to one past the last row in this sheet.
#### ```const_iterator xlnt::worksheet::cbegin() const```
Return a constant iterator to the first row in this sheet.
#### ```const_iterator xlnt::worksheet::cend() const```
Returns a constant iterator to one past the last row in this sheet.
#### ```void xlnt::worksheet::print_title_rows(row_t first_row, row_t last_row)```
Sets rows to repeat at top during printing.
#### ```void xlnt::worksheet::print_title_rows(row_t last_row)```
Sets rows to repeat at top during printing.
#### ```void xlnt::worksheet::print_title_cols(column_t first_column, column_t last_column)```
Sets columns to repeat at left during printing.
#### ```void xlnt::worksheet::print_title_cols(column_t last_column)```
Sets columns to repeat at left during printing.
#### ```std::string xlnt::worksheet::print_titles() const```
Returns a string representation of the defined print titles.
#### ```void xlnt::worksheet::print_area(const std::string &print_area)```
Sets the print area of this sheet to print_area.
#### ```range_reference xlnt::worksheet::print_area() const```
Returns the print area defined for this sheet.
#### ```bool xlnt::worksheet::has_view() const```
Returns true if this sheet has any number of views defined.
#### ```sheet_view xlnt::worksheet::view(std::size_t index=0) const```
Returns the view at the given index.
#### ```void xlnt::worksheet::add_view(const sheet_view &new_view)```
Adds new_view to the set of available views for this sheet.
#### ```void xlnt::worksheet::clear_page_breaks()```
Remove all manual column and row page breaks (represented as dashed blue lines in the page view in Excel).
#### ```const std::vector<row_t>& xlnt::worksheet::page_break_rows() const```
Returns vector where each element represents a row which will break a page below it.
#### ```void xlnt::worksheet::page_break_at_row(row_t row)```
Add a page break at the given row.
#### ```const std::vector<column_t>& xlnt::worksheet::page_break_columns() const```
Returns vector where each element represents a column which will break a page to the right.
#### ```void xlnt::worksheet::page_break_at_column(column_t column)```
Add a page break at the given column.