# 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& 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(T value)``` Sets the value of this cell to the given value. 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::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 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 &value)``` Adds a hyperlink to this cell pointing to the URI of the given value. #### ```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. #### ```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``` ### cell_reference #### ```static std::pair xlnt::cell_reference::split_reference(const std::string &reference_string)``` Split a coordinate string like "A1" into an equivalent pair like {"A", 1}. #### ```static std::pair xlnt::cell_reference::split_reference(const std::string &reference_string, bool &absolute_column, bool &absolute_row)``` Split 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)``` Convert 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``` Return true if the reference refers to an absolute column, otherwise false. #### ```void xlnt::cell_reference::column_absolute(bool absolute_column)``` Make this reference have an absolute column if absolute_column is true, otherwise not absolute. #### ```bool xlnt::cell_reference::row_absolute() const``` Return true if the reference refers to an absolute row, otherwise false. #### ```void xlnt::cell_reference::row_absolute(bool absolute_row)``` Make this reference have an absolute row if absolute_row is true, otherwise not absolute. #### ```column_t xlnt::cell_reference::column() const``` Return 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)``` Set the column of this reference from a string that identifies a particular column. #### ```column_t::index_t xlnt::cell_reference::column_index() const``` Return a 1-indexed numeric index of the column of this reference. #### ```void xlnt::cell_reference::column_index(column_t column)``` Set the column of this reference from a 1-indexed number that identifies a particular column. #### ```row_t xlnt::cell_reference::row() const``` Return a 1-indexed numeric index of the row of this reference. #### ```void xlnt::cell_reference::row(row_t row)``` Set 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``` Return 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``` Return a string like "A1" for cell_reference(1, 1). #### ```range_reference xlnt::cell_reference::to_range() const``` Return 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``` Return 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``` Construct a cell_reference from reference_string and return the result of their comparison. #### ```bool xlnt::cell_reference::operator==(const char *reference_string) const``` Construct a cell_reference from reference_string and return the result of their comparison. #### ```bool xlnt::cell_reference::operator!=(const cell_reference &comparand) const``` Return 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``` Construct a cell_reference from reference_string and return the result of their comparison. #### ```bool xlnt::cell_reference::operator!=(const char *reference_string) const``` Construct 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``` Return the text that will be displayed for this comment. #### ```std::string xlnt::comment::plain_text() const``` Return the plain text that will be displayed for this comment without formatting information. #### ```std::string xlnt::comment::author() const``` Return the author of this comment. #### ```void xlnt::comment::hide()``` Make this comment only visible when the associated cell is hovered. #### ```void xlnt::comment::show()``` Make 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)``` Set 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)``` Set 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 operator==(const comment &left, const comment &right)``` Return true if both comments are equivalent. ### column_t #### ```using xlnt::column_t::index_t = std::uint32_tundefined``` #### ```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 column_t is the first (left-most) column. #### ```xlnt::column_t::column_t(index_t column_index)``` Construct a column from a number. #### ```xlnt::column_t::column_t(const std::string &column_string)``` Construct a column from a string. #### ```xlnt::column_t::column_t(const char *column_string)``` Construct a column from a string. #### ```xlnt::column_t::column_t(const column_t &other)``` Copy constructor #### ```xlnt::column_t::column_t(column_t &&other)``` Move constructor #### ```std::string xlnt::column_t::column_string() const``` Return a string representation of this column index. #### ```column_t& xlnt::column_t::operator=(column_t rhs)``` Set this column to be the same as rhs's and return reference to self. #### ```column_t& xlnt::column_t::operator=(const std::string &rhs)``` Set this column to be equal to rhs and return reference to self. #### ```column_t& xlnt::column_t::operator=(const char *rhs)``` Set this column to be equal to rhs and return reference to self. #### ```bool xlnt::column_t::operator==(const column_t &other) const``` Return true if this column refers to the same column as other. #### ```bool xlnt::column_t::operator!=(const column_t &other) const``` Return true if this column doesn't refer to the same column as other. #### ```bool xlnt::column_t::operator==(int other) const``` Return true if this column refers to the same column as other. #### ```bool xlnt::column_t::operator==(index_t other) const``` Return true if this column refers to the same column as other. #### ```bool xlnt::column_t::operator==(const std::string &other) const``` Return true if this column refers to the same column as other. #### ```bool xlnt::column_t::operator==(const char *other) const``` Return true if this column refers to the same column as other. #### ```bool xlnt::column_t::operator!=(int other) const``` Return true if this column doesn't refer to the same column as other. #### ```bool xlnt::column_t::operator!=(index_t other) const``` Return true if this column doesn't refer to the same column as other. #### ```bool xlnt::column_t::operator!=(const std::string &other) const``` Return true if this column doesn't refer to the same column as other. #### ```bool xlnt::column_t::operator!=(const char *other) const``` Return true if this column doesn't refer to the same column as other. #### ```bool xlnt::column_t::operator>(const column_t &other) const``` Return true if other is to the right of this column. #### ```bool xlnt::column_t::operator>=(const column_t &other) const``` Return true if other is to the right of or equal to this column. #### ```bool xlnt::column_t::operator<(const column_t &other) const``` Return true if other is to the left of this column. #### ```bool xlnt::column_t::operator<=(const column_t &other) const``` Return 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``` Return true if other is to the right of this column. #### ```bool xlnt::column_t::operator>=(const column_t::index_t &other) const``` Return 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``` Return true if other is to the left of this column. #### ```bool xlnt::column_t::operator<=(const column_t::index_t &other) const``` Return true if other is to the left of or equal to this column. #### ```column_t& xlnt::column_t::operator++()``` Pre-increment this column, making it point to the column one to the right. #### ```column_t& xlnt::column_t::operator--()``` Pre-deccrement this column, making it point to the column one to the left. #### ```column_t xlnt::column_t::operator++(int)``` Post-increment 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-decrement 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)``` Add rhs to this column and return a reference to this column. #### ```column_t& xlnt::column_t::operator-=(const column_t &rhs)``` Subtrac rhs from this column and return a reference to this column. #### ```column_t& xlnt::column_t::operator*=(const column_t &rhs)``` Multiply this column by rhs and return a reference to this column. #### ```column_t& xlnt::column_t::operator/=(const column_t &rhs)``` Divide this column by rhs and return a reference to this column. #### ```column_t& xlnt::column_t::operator%=(const column_t &rhs)``` Mod this column by rhs and return a reference to this column. #### ```column_t operator+(column_t lhs, const column_t &rhs)``` Return the result of adding rhs to this column. #### ```column_t operator-(column_t lhs, const column_t &rhs)``` Return the result of subtracing lhs by rhs column. #### ```column_t operator*(column_t lhs, const column_t &rhs)``` Return the result of multiply lhs by rhs column. #### ```column_t operator/(column_t lhs, const column_t &rhs)``` Return the result of divide lhs by rhs column. #### ```column_t operator%(column_t lhs, const column_t &rhs)``` Return the result of mod lhs by rhs column. #### ```bool operator>(const column_t::index_t &left, const column_t &right)``` Return true if other is to the right of this column. #### ```bool operator>=(const column_t::index_t &left, const column_t &right)``` Return 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)``` Return true if other is to the left of this column. #### ```bool operator<=(const column_t::index_t &left, const column_t &right)``` Return true if other is to the left of or equal to this column. #### ```void swap(column_t &left, column_t &right)``` Swap the columns that left and right refer to. ### column_hash #### ```std::size_t xlnt::column_hash::operator()(const column_t &k) const``` ### column_t > #### ```size_t std::hash< xlnt::column_t >::operator()(const xlnt::column_t &k) const``` ### rich_text #### ```xlnt::rich_text::rich_text()=default``` #### ```xlnt::rich_text::rich_text(const std::string &plain_text)``` #### ```xlnt::rich_text::rich_text(const std::string &plain_text, const class font &text_font)``` #### ```xlnt::rich_text::rich_text(const rich_text_run &single_run)``` #### ```void xlnt::rich_text::clear()``` Remove all text runs from this text. #### ```void xlnt::rich_text::plain_text(const std::string &s)``` Clear any runs in this text and add a single run with default formatting and the given string as its textual content. #### ```std::string xlnt::rich_text::plain_text() const``` Combine the textual content of each text run in order and return the result. #### ```std::vector 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)``` Set the runs of this text all at once. #### ```void xlnt::rich_text::add_run(const rich_text_run &t)``` Add 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 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::manifest::relationships(const path &source) const``` Returns all relationship with "source" as the source. #### ```std::vector 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)``` #### ```std::string xlnt::manifest::register_relationship(const class relationship &rel)``` #### ```std::unordered_map 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 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 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()``` #### ```xlnt::relationship::relationship(const std::string &id, relationship_type t, const uri &source, const uri &target, xlnt::target_mode mode)``` #### ```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()``` #### ```xlnt::uri::uri(const uri &base, const uri &relative)``` #### ```xlnt::uri::uri(const uri &base, const path &relative)``` #### ```xlnt::uri::uri(const std::string &uri_string)``` #### ```bool xlnt::uri::is_relative() const``` #### ```bool xlnt::uri::is_absolute() const``` #### ```std::string xlnt::uri::scheme() const``` #### ```std::string xlnt::uri::authority() const``` #### ```bool xlnt::uri::has_authentication() const``` #### ```std::string xlnt::uri::authentication() const``` #### ```std::string xlnt::uri::username() const``` #### ```std::string xlnt::uri::password() const``` #### ```std::string xlnt::uri::host() const``` #### ```bool xlnt::uri::has_port() const``` #### ```std::size_t xlnt::uri::port() const``` #### ```class path xlnt::uri::path() const``` #### ```bool xlnt::uri::has_query() const``` #### ```std::string xlnt::uri::query() const``` #### ```bool xlnt::uri::has_fragment() const``` #### ```std::string xlnt::uri::fragment() const``` #### ```std::string xlnt::uri::to_string() const``` #### ```uri xlnt::uri::make_absolute(const uri &base)``` #### ```uri xlnt::uri::make_reference(const uri &base)``` #### ```bool operator==(const uri &left, const uri &right)``` ## Styles Module ### alignment #### ```bool xlnt::alignment::shrink() const``` #### ```alignment& xlnt::alignment::shrink(bool shrink_to_fit)``` #### ```bool xlnt::alignment::wrap() const``` #### ```alignment& xlnt::alignment::wrap(bool wrap_text)``` #### ```optional xlnt::alignment::indent() const``` #### ```alignment& xlnt::alignment::indent(int indent_size)``` #### ```optional xlnt::alignment::rotation() const``` #### ```alignment& xlnt::alignment::rotation(int text_rotation)``` #### ```optional xlnt::alignment::horizontal() const``` #### ```alignment& xlnt::alignment::horizontal(horizontal_alignment horizontal)``` #### ```optional xlnt::alignment::vertical() const``` #### ```alignment& xlnt::alignment::vertical(vertical_alignment vertical)``` #### ```bool operator==(const alignment &left, const alignment &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const alignment &left, const alignment &right)``` Returns true if left is not exactly equal to right. ### border #### ```static const std::vector& xlnt::border::all_sides()``` #### ```xlnt::border::border()``` #### ```optional xlnt::border::side(border_side s) const``` #### ```border& xlnt::border::side(border_side s, const border_property &prop)``` #### ```optional xlnt::border::diagonal() const``` #### ```border& xlnt::border::diagonal(diagonal_direction dir)``` #### ```bool operator==(const border &left, const border &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const border &left, const border &right)``` Returns true if left is not exactly equal to right. ### border_property #### ```optional xlnt::border::border_property::color() const``` #### ```border_property& xlnt::border::border_property::color(const xlnt::color &c)``` #### ```optional xlnt::border::border_property::style() const``` #### ```border_property& xlnt::border::border_property::style(border_style style)``` #### ```bool operator==(const border_property &left, const border_property &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const border_property &left, const border_property &right)``` Returns true if left is not exactly equal to right. ### indexed_color #### ```xlnt::indexed_color::indexed_color(std::size_t index)``` #### ```std::size_t xlnt::indexed_color::index() const``` #### ```void xlnt::indexed_color::index(std::size_t index)``` ### theme_color #### ```xlnt::theme_color::theme_color(std::size_t index)``` #### ```std::size_t xlnt::theme_color::index() const``` #### ```void xlnt::theme_color::index(std::size_t index)``` ### rgb_color #### ```xlnt::rgb_color::rgb_color(const std::string &hex_string)``` #### ```xlnt::rgb_color::rgb_color(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t a=255)``` #### ```std::string xlnt::rgb_color::hex_string() const``` #### ```std::uint8_t xlnt::rgb_color::red() const``` #### ```std::uint8_t xlnt::rgb_color::green() const``` #### ```std::uint8_t xlnt::rgb_color::blue() const``` #### ```std::uint8_t xlnt::rgb_color::alpha() const``` #### ```std::array xlnt::rgb_color::rgb() const``` #### ```std::array xlnt::rgb_color::rgba() const``` ### color #### ```static const color xlnt::color::black()``` #### ```static const color xlnt::color::white()``` #### ```static const color xlnt::color::red()``` #### ```static const color xlnt::color::darkred()``` #### ```static const color xlnt::color::blue()``` #### ```static const color xlnt::color::darkblue()``` #### ```static const color xlnt::color::green()``` #### ```static const color xlnt::color::darkgreen()``` #### ```static const color xlnt::color::yellow()``` #### ```static const color xlnt::color::darkyellow()``` #### ```xlnt::color::color()``` #### ```xlnt::color::color(const rgb_color &rgb)``` #### ```xlnt::color::color(const indexed_color &indexed)``` #### ```xlnt::color::color(const theme_color &theme)``` #### ```color_type xlnt::color::type() const``` #### ```bool xlnt::color::is_auto() const``` #### ```void xlnt::color::auto_(bool value)``` #### ```const rgb_color& xlnt::color::rgb() const``` #### ```const indexed_color& xlnt::color::indexed() const``` #### ```const theme_color& xlnt::color::theme() const``` #### ```double xlnt::color::tint() const``` #### ```void xlnt::color::tint(double tint)``` #### ```bool xlnt::color::operator==(const color &other) const``` #### ```bool xlnt::color::operator!=(const color &other) const``` ### pattern_fill #### ```xlnt::pattern_fill::pattern_fill()``` #### ```pattern_fill_type xlnt::pattern_fill::type() const``` #### ```pattern_fill& xlnt::pattern_fill::type(pattern_fill_type new_type)``` #### ```optional xlnt::pattern_fill::foreground() const``` #### ```pattern_fill& xlnt::pattern_fill::foreground(const color &foreground)``` #### ```optional xlnt::pattern_fill::background() const``` #### ```pattern_fill& xlnt::pattern_fill::background(const color &background)``` #### ```bool operator==(const pattern_fill &left, const pattern_fill &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const pattern_fill &left, const pattern_fill &right)``` Returns true if left is not exactly equal to right. ### gradient_fill #### ```xlnt::gradient_fill::gradient_fill()``` #### ```gradient_fill_type xlnt::gradient_fill::type() const``` #### ```gradient_fill& xlnt::gradient_fill::type(gradient_fill_type new_type)``` #### ```gradient_fill& xlnt::gradient_fill::degree(double degree)``` #### ```double xlnt::gradient_fill::degree() const``` #### ```double xlnt::gradient_fill::left() const``` #### ```gradient_fill& xlnt::gradient_fill::left(double value)``` #### ```double xlnt::gradient_fill::right() const``` #### ```gradient_fill& xlnt::gradient_fill::right(double value)``` #### ```double xlnt::gradient_fill::top() const``` #### ```gradient_fill& xlnt::gradient_fill::top(double value)``` #### ```double xlnt::gradient_fill::bottom() const``` #### ```gradient_fill& xlnt::gradient_fill::bottom(double value)``` #### ```gradient_fill& xlnt::gradient_fill::add_stop(double position, color stop_color)``` #### ```gradient_fill& xlnt::gradient_fill::clear_stops()``` #### ```std::unordered_map xlnt::gradient_fill::stops() const``` #### ```bool operator==(const gradient_fill &left, const gradient_fill &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const gradient_fill &left, const gradient_fill &right)``` Returns true if left is not exactly equal to right. ### 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 operator==(const fill &left, const fill &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const fill &left, const fill &right)``` Returns true if left is not exactly equal to right. ### font #### ```undefinedundefined``` #### ```bool operator==(const font &left, const font &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const font &left, const font &right)``` Returns true if left is not exactly equal to right. #### ```xlnt::font::font()``` #### ```font& xlnt::font::bold(bool bold)``` #### ```bool xlnt::font::bold() const``` #### ```font& xlnt::font::superscript(bool superscript)``` #### ```bool xlnt::font::superscript() const``` #### ```font& xlnt::font::italic(bool italic)``` #### ```bool xlnt::font::italic() const``` #### ```font& xlnt::font::strikethrough(bool strikethrough)``` #### ```bool xlnt::font::strikethrough() const``` #### ```font& xlnt::font::underline(underline_style new_underline)``` #### ```bool xlnt::font::underlined() const``` #### ```underline_style xlnt::font::underline() const``` #### ```bool xlnt::font::has_size() const``` #### ```font& xlnt::font::size(double size)``` #### ```double xlnt::font::size() const``` #### ```bool xlnt::font::has_name() const``` #### ```font& xlnt::font::name(const std::string &name)``` #### ```std::string xlnt::font::name() const``` #### ```bool xlnt::font::has_color() const``` #### ```font& xlnt::font::color(const color &c)``` #### ```xlnt::color xlnt::font::color() const``` #### ```bool xlnt::font::has_family() const``` #### ```font& xlnt::font::family(std::size_t family)``` #### ```std::size_t xlnt::font::family() const``` #### ```bool xlnt::font::has_scheme() const``` #### ```font& xlnt::font::scheme(const std::string &scheme)``` #### ```std::string xlnt::font::scheme() const``` ### format #### ```friend struct detail::stylesheetundefined``` #### ```std::size_t xlnt::format::id() const``` #### ```class alignment& xlnt::format::alignment()``` #### ```const class alignment& xlnt::format::alignment() const``` #### ```format xlnt::format::alignment(const xlnt::alignment &new_alignment, bool applied)``` #### ```bool xlnt::format::alignment_applied() const``` #### ```class border& xlnt::format::border()``` #### ```const class border& xlnt::format::border() const``` #### ```format xlnt::format::border(const xlnt::border &new_border, bool applied)``` #### ```bool xlnt::format::border_applied() const``` #### ```class fill& xlnt::format::fill()``` #### ```const class fill& xlnt::format::fill() const``` #### ```format xlnt::format::fill(const xlnt::fill &new_fill, bool applied)``` #### ```bool xlnt::format::fill_applied() const``` #### ```class font& xlnt::format::font()``` #### ```const class font& xlnt::format::font() const``` #### ```format xlnt::format::font(const xlnt::font &new_font, bool applied)``` #### ```bool xlnt::format::font_applied() const``` #### ```class number_format& xlnt::format::number_format()``` #### ```const class number_format& xlnt::format::number_format() const``` #### ```format xlnt::format::number_format(const xlnt::number_format &new_number_format, bool applied)``` #### ```bool xlnt::format::number_format_applied() const``` #### ```class protection& xlnt::format::protection()``` #### ```const class protection& xlnt::format::protection() const``` #### ```format xlnt::format::protection(const xlnt::protection &new_protection, bool applied)``` #### ```bool xlnt::format::protection_applied() const``` #### ```bool xlnt::format::has_style() const``` #### ```void xlnt::format::clear_style()``` #### ```format xlnt::format::style(const std::string &name)``` #### ```format xlnt::format::style(const class style &new_style)``` #### ```const class style xlnt::format::style() const``` ### number_format #### ```static const number_format xlnt::number_format::general()``` #### ```static const number_format xlnt::number_format::text()``` #### ```static const number_format xlnt::number_format::number()``` #### ```static const number_format xlnt::number_format::number_00()``` #### ```static const number_format xlnt::number_format::number_comma_separated1()``` #### ```static const number_format xlnt::number_format::percentage()``` #### ```static const number_format xlnt::number_format::percentage_00()``` #### ```static const number_format xlnt::number_format::date_yyyymmdd2()``` #### ```static const number_format xlnt::number_format::date_yymmdd()``` #### ```static const number_format xlnt::number_format::date_ddmmyyyy()``` #### ```static const number_format xlnt::number_format::date_dmyslash()``` #### ```static const number_format xlnt::number_format::date_dmyminus()``` #### ```static const number_format xlnt::number_format::date_dmminus()``` #### ```static const number_format xlnt::number_format::date_myminus()``` #### ```static const number_format xlnt::number_format::date_xlsx14()``` #### ```static const number_format xlnt::number_format::date_xlsx15()``` #### ```static const number_format xlnt::number_format::date_xlsx16()``` #### ```static const number_format xlnt::number_format::date_xlsx17()``` #### ```static const number_format xlnt::number_format::date_xlsx22()``` #### ```static const number_format xlnt::number_format::date_datetime()``` #### ```static const number_format xlnt::number_format::date_time1()``` #### ```static const number_format xlnt::number_format::date_time2()``` #### ```static const number_format xlnt::number_format::date_time3()``` #### ```static const number_format xlnt::number_format::date_time4()``` #### ```static const number_format xlnt::number_format::date_time5()``` #### ```static const number_format xlnt::number_format::date_time6()``` #### ```static bool xlnt::number_format::is_builtin_format(std::size_t builtin_id)``` #### ```static const number_format& xlnt::number_format::from_builtin_id(std::size_t builtin_id)``` #### ```xlnt::number_format::number_format()``` #### ```xlnt::number_format::number_format(std::size_t builtin_id)``` #### ```xlnt::number_format::number_format(const std::string &code)``` #### ```xlnt::number_format::number_format(const std::string &code, std::size_t custom_id)``` #### ```void xlnt::number_format::format_string(const std::string &format_code)``` #### ```void xlnt::number_format::format_string(const std::string &format_code, std::size_t custom_id)``` #### ```std::string xlnt::number_format::format_string() const``` #### ```bool xlnt::number_format::has_id() const``` #### ```void xlnt::number_format::id(std::size_t id)``` #### ```std::size_t xlnt::number_format::id() const``` #### ```std::string xlnt::number_format::format(const std::string &text) const``` #### ```std::string xlnt::number_format::format(long double number, calendar base_date) const``` #### ```bool xlnt::number_format::is_date_format() const``` #### ```bool operator==(const number_format &left, const number_format &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const number_format &left, const number_format &right)``` Returns true if left is not exactly equal to right. ### protection #### ```static protection xlnt::protection::unlocked_and_visible()``` #### ```static protection xlnt::protection::locked_and_visible()``` #### ```static protection xlnt::protection::unlocked_and_hidden()``` #### ```static protection xlnt::protection::locked_and_hidden()``` #### ```xlnt::protection::protection()``` #### ```bool xlnt::protection::locked() const``` #### ```protection& xlnt::protection::locked(bool locked)``` #### ```bool xlnt::protection::hidden() const``` #### ```protection& xlnt::protection::hidden(bool hidden)``` #### ```bool operator==(const protection &left, const protection &right)``` Returns true if left is exactly equal to right. #### ```bool operator!=(const protection &left, const protection &right)``` Returns true if left is not exactly equal 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 #### ```std::string xlnt::style::name() const``` Return the name of this style. #### ```style xlnt::style::name(const std::string &name)``` #### ```bool xlnt::style::hidden() const``` #### ```style xlnt::style::hidden(bool value)``` #### ```optional xlnt::style::custom() const``` #### ```style xlnt::style::custom(bool value)``` #### ```optional xlnt::style::builtin_id() const``` #### ```style xlnt::style::builtin_id(std::size_t builtin_id)``` #### ```class alignment& xlnt::style::alignment()``` #### ```const class alignment& xlnt::style::alignment() const``` #### ```style xlnt::style::alignment(const xlnt::alignment &new_alignment, bool applied=true)``` #### ```bool xlnt::style::alignment_applied() const``` #### ```class border& xlnt::style::border()``` #### ```const class border& xlnt::style::border() const``` #### ```style xlnt::style::border(const xlnt::border &new_border, bool applied=true)``` #### ```bool xlnt::style::border_applied() const``` #### ```class fill& xlnt::style::fill()``` #### ```const class fill& xlnt::style::fill() const``` #### ```style xlnt::style::fill(const xlnt::fill &new_fill, bool applied=true)``` #### ```bool xlnt::style::fill_applied() const``` #### ```class font& xlnt::style::font()``` #### ```const class font& xlnt::style::font() const``` #### ```style xlnt::style::font(const xlnt::font &new_font, bool applied=true)``` #### ```bool xlnt::style::font_applied() const``` #### ```class number_format& xlnt::style::number_format()``` #### ```const class number_format& xlnt::style::number_format() const``` #### ```style xlnt::style::number_format(const xlnt::number_format &new_number_format, bool applied=true)``` #### ```bool xlnt::style::number_format_applied() const``` #### ```class protection& xlnt::style::protection()``` #### ```const class protection& xlnt::style::protection() const``` #### ```style xlnt::style::protection(const xlnt::protection &new_protection, bool applied=true)``` #### ```bool xlnt::style::protection_applied() const``` #### ```bool xlnt::style::operator==(const style &other) const``` ## Utils Module ### date #### ```int xlnt::date::yearundefined``` #### ```int xlnt::date::monthundefined``` #### ```int xlnt::date::dayundefined``` #### ```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_)``` #### ```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``` #### ```bool xlnt::date::operator==(const date &comparand) const``` Return true if this date is equal to comparand. ### datetime #### ```int xlnt::datetime::yearundefined``` #### ```int xlnt::datetime::monthundefined``` #### ```int xlnt::datetime::dayundefined``` #### ```int xlnt::datetime::hourundefined``` #### ```int xlnt::datetime::minuteundefined``` #### ```int xlnt::datetime::secondundefined``` #### ```int xlnt::datetime::microsecondundefined``` #### ```static datetime xlnt::datetime::now()``` Return the current date and time according to the system time. #### ```static datetime xlnt::datetime::today()``` Return 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)``` Return 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)``` #### ```xlnt::datetime::datetime(const date &d, const time &t)``` #### ```xlnt::datetime::datetime(int year_, int month_, int day_, int hour_=0, int minute_=0, int second_=0, int microsecond_=0)``` #### ```std::string xlnt::datetime::to_string() const``` #### ```std::string xlnt::datetime::to_iso_string() const``` #### ```long double xlnt::datetime::to_number(calendar base_date) const``` #### ```bool xlnt::datetime::operator==(const datetime &comparand) const``` #### ```int xlnt::datetime::weekday() const``` ### exception #### ```xlnt::exception::exception(const std::string &message)``` #### ```xlnt::exception::exception(const exception &)=default``` #### ```virtual xlnt::exception::~exception()``` #### ```void xlnt::exception::message(const std::string &message)``` ### invalid_parameter #### ```xlnt::invalid_parameter::invalid_parameter()``` #### ```xlnt::invalid_parameter::invalid_parameter(const invalid_parameter &)=default``` #### ```virtual xlnt::invalid_parameter::~invalid_parameter()``` ### invalid_sheet_title #### ```xlnt::invalid_sheet_title::invalid_sheet_title(const std::string &title)``` #### ```xlnt::invalid_sheet_title::invalid_sheet_title(const invalid_sheet_title &)=default``` #### ```virtual xlnt::invalid_sheet_title::~invalid_sheet_title()``` ### missing_number_format #### ```xlnt::missing_number_format::missing_number_format()``` #### ```virtual xlnt::missing_number_format::~missing_number_format()``` ### invalid_file #### ```xlnt::invalid_file::invalid_file(const std::string &filename)``` #### ```xlnt::invalid_file::invalid_file(const invalid_file &)=default``` #### ```virtual xlnt::invalid_file::~invalid_file()``` ### illegal_character #### ```xlnt::illegal_character::illegal_character(char c)``` #### ```xlnt::illegal_character::illegal_character(const illegal_character &)=default``` #### ```virtual xlnt::illegal_character::~illegal_character()``` ### invalid_data_type #### ```xlnt::invalid_data_type::invalid_data_type()``` #### ```xlnt::invalid_data_type::invalid_data_type(const invalid_data_type &)=default``` #### ```virtual xlnt::invalid_data_type::~invalid_data_type()``` ### invalid_column_string_index #### ```xlnt::invalid_column_string_index::invalid_column_string_index()``` #### ```xlnt::invalid_column_string_index::invalid_column_string_index(const invalid_column_string_index &)=default``` #### ```virtual xlnt::invalid_column_string_index::~invalid_column_string_index()``` ### invalid_cell_reference #### ```xlnt::invalid_cell_reference::invalid_cell_reference(column_t column, row_t row)``` #### ```xlnt::invalid_cell_reference::invalid_cell_reference(const std::string &reference_string)``` #### ```xlnt::invalid_cell_reference::invalid_cell_reference(const invalid_cell_reference &)=default``` #### ```virtual xlnt::invalid_cell_reference::~invalid_cell_reference()``` ### invalid_attribute #### ```xlnt::invalid_attribute::invalid_attribute()``` #### ```xlnt::invalid_attribute::invalid_attribute(const invalid_attribute &)=default``` #### ```virtual xlnt::invalid_attribute::~invalid_attribute()``` ### key_not_found #### ```xlnt::key_not_found::key_not_found()``` #### ```xlnt::key_not_found::key_not_found(const key_not_found &)=default``` #### ```virtual xlnt::key_not_found::~key_not_found()``` ### no_visible_worksheets #### ```xlnt::no_visible_worksheets::no_visible_worksheets()``` #### ```xlnt::no_visible_worksheets::no_visible_worksheets(const no_visible_worksheets &)=default``` #### ```virtual xlnt::no_visible_worksheets::~no_visible_worksheets()``` ### unhandled_switch_case #### ```xlnt::unhandled_switch_case::unhandled_switch_case()``` #### ```virtual xlnt::unhandled_switch_case::~unhandled_switch_case()``` ### unsupported #### ```xlnt::unsupported::unsupported(const std::string &message)``` #### ```xlnt::unsupported::unsupported(const unsupported &)=default``` #### ```virtual xlnt::unsupported::~unsupported()``` ### 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 xlnt::path::split_extension() const``` Return a pair of strings resulting from splitting the filename on the last dot. #### ```std::vector 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 operator==(const path &left, const path &right)``` Returns true if left path is equal to right path. ### path > #### ```size_t std::hash< xlnt::path >::operator()(const xlnt::path &p) const``` ### scoped_enum_hash #### ```std::size_t xlnt::scoped_enum_hash< Enum >::operator()(Enum e) const``` ### time #### ```int xlnt::time::hourundefined``` #### ```int xlnt::time::minuteundefined``` #### ```int xlnt::time::secondundefined``` #### ```int xlnt::time::microsecondundefined``` #### ```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)``` #### ```xlnt::time::time(const std::string &time_string)``` #### ```long double xlnt::time::to_number() const``` #### ```bool xlnt::time::operator==(const time &comparand) const``` ### timedelta #### ```int xlnt::timedelta::daysundefined``` #### ```int xlnt::timedelta::hoursundefined``` #### ```int xlnt::timedelta::minutesundefined``` #### ```int xlnt::timedelta::secondsundefined``` #### ```int xlnt::timedelta::microsecondsundefined``` #### ```static timedelta xlnt::timedelta::from_number(long double number)``` #### ```xlnt::timedelta::timedelta()``` #### ```xlnt::timedelta::timedelta(int days_, int hours_, int minutes_, int seconds_, int microseconds_)``` #### ```long double xlnt::timedelta::to_number() const``` ### variant #### ```undefinedundefined``` #### ```xlnt::variant::variant()``` #### ```xlnt::variant::variant(const std::string &value)``` #### ```xlnt::variant::variant(const char *value)``` #### ```xlnt::variant::variant(int value)``` #### ```xlnt::variant::variant(bool value)``` #### ```xlnt::variant::variant(const datetime &value)``` #### ```xlnt::variant::variant(const std::initializer_list< int > &value)``` #### ```xlnt::variant::variant(const std::vector< int > &value)``` #### ```xlnt::variant::variant(const std::initializer_list< const char *> &value)``` #### ```xlnt::variant::variant(const std::vector< const char *> &value)``` #### ```xlnt::variant::variant(const std::initializer_list< std::string > &value)``` #### ```xlnt::variant::variant(const std::vector< std::string > &value)``` #### ```xlnt::variant::variant(const std::vector< variant > &value)``` #### ```bool xlnt::variant::is(type t) const``` #### ```T xlnt::variant::get() const``` #### ```type xlnt::variant::value_type() const``` ## Workbook Module ### calculation_properties #### ```std::size_t xlnt::calculation_properties::calc_idundefined``` Uniquely identifies these calculation properties. #### ```bool xlnt::calculation_properties::concurrent_calcundefined``` If this is true, concurrent calculation is enabled. ### const_worksheet_iterator #### ```xlnt::const_worksheet_iterator::const_worksheet_iterator(const workbook &wb, std::size_t index)``` #### ```xlnt::const_worksheet_iterator::const_worksheet_iterator(const const_worksheet_iterator &)``` #### ```const_worksheet_iterator& xlnt::const_worksheet_iterator::operator=(const const_worksheet_iterator &)``` #### ```const worksheet xlnt::const_worksheet_iterator::operator*()``` #### ```bool xlnt::const_worksheet_iterator::operator==(const const_worksheet_iterator &comparand) const``` #### ```bool xlnt::const_worksheet_iterator::operator!=(const const_worksheet_iterator &comparand) const``` #### ```const_worksheet_iterator xlnt::const_worksheet_iterator::operator++(int)``` #### ```const_worksheet_iterator& xlnt::const_worksheet_iterator::operator++()``` ### document_security #### ```bool xlnt::document_security::lock_revisionundefined``` #### ```bool xlnt::document_security::lock_structureundefined``` #### ```bool xlnt::document_security::lock_windowsundefined``` #### ```std::string xlnt::document_security::revision_passwordundefined``` #### ```std::string xlnt::document_security::workbook_passwordundefined``` #### ```xlnt::document_security::document_security()``` ### external_book ### named_range #### ```using xlnt::named_range::target = std::pairundefined``` #### ```xlnt::named_range::named_range()``` #### ```xlnt::named_range::named_range(const named_range &other)``` #### ```xlnt::named_range::named_range(const std::string &name, const std::vector< target > &targets)``` #### ```std::string xlnt::named_range::name() const``` #### ```const std::vector& xlnt::named_range::targets() const``` #### ```named_range& xlnt::named_range::operator=(const named_range &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_iteratorundefined``` 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_iteratorundefined``` 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``` #### ```void swap(workbook &left, workbook &right)``` Swaps the data held in workbooks "left" and "right". #### ```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 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::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::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 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::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)``` 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)``` 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)``` 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. #### ```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& xlnt::workbook::shared_strings()``` Returns a reference to the shared strings being used by cells in this workbook. #### ```const std::vector& 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& 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``` #### ```bool xlnt::workbook_view::minimizedundefined``` #### ```bool xlnt::workbook_view::show_horizontal_scrollundefined``` #### ```bool xlnt::workbook_view::show_sheet_tabsundefined``` #### ```bool xlnt::workbook_view::show_vertical_scrollundefined``` #### ```bool xlnt::workbook_view::visibleundefined``` #### ```optional xlnt::workbook_view::active_tabundefined``` #### ```optional xlnt::workbook_view::first_sheetundefined``` #### ```optional xlnt::workbook_view::tab_ratioundefined``` #### ```optional xlnt::workbook_view::window_widthundefined``` #### ```optional xlnt::workbook_view::window_heightundefined``` #### ```optional xlnt::workbook_view::x_windowundefined``` #### ```optional xlnt::workbook_view::y_windowundefined``` ### worksheet_iterator #### ```xlnt::worksheet_iterator::worksheet_iterator(workbook &wb, std::size_t index)``` #### ```xlnt::worksheet_iterator::worksheet_iterator(const worksheet_iterator &)``` #### ```worksheet_iterator& xlnt::worksheet_iterator::operator=(const worksheet_iterator &)``` #### ```worksheet xlnt::worksheet_iterator::operator*()``` #### ```bool xlnt::worksheet_iterator::operator==(const worksheet_iterator &comparand) const``` #### ```bool xlnt::worksheet_iterator::operator!=(const worksheet_iterator &comparand) const``` #### ```worksheet_iterator xlnt::worksheet_iterator::operator++(int)``` #### ```worksheet_iterator& xlnt::worksheet_iterator::operator++()``` ## Worksheet Module ### cell_iterator #### ```xlnt::cell_iterator::cell_iterator(worksheet ws, const cell_reference &start_cell, const range_reference &limits)``` #### ```xlnt::cell_iterator::cell_iterator(worksheet ws, const cell_reference &start_cell, const range_reference &limits, major_order order)``` #### ```xlnt::cell_iterator::cell_iterator(const cell_iterator &other)``` #### ```cell xlnt::cell_iterator::operator*()``` #### ```cell_iterator& xlnt::cell_iterator::operator=(const cell_iterator &)=default``` #### ```bool xlnt::cell_iterator::operator==(const cell_iterator &other) const``` #### ```bool xlnt::cell_iterator::operator!=(const cell_iterator &other) const``` #### ```cell_iterator& xlnt::cell_iterator::operator--()``` #### ```cell_iterator xlnt::cell_iterator::operator--(int)``` #### ```cell_iterator& xlnt::cell_iterator::operator++()``` #### ```cell_iterator xlnt::cell_iterator::operator++(int)``` ### cell_vector #### ```using xlnt::cell_vector::iterator = cell_iteratorundefined``` #### ```using xlnt::cell_vector::const_iterator = const_cell_iteratorundefined``` #### ```using xlnt::cell_vector::reverse_iterator = std::reverse_iteratorundefined``` #### ```using xlnt::cell_vector::const_reverse_iterator = std::reverse_iteratorundefined``` #### ```xlnt::cell_vector::cell_vector(worksheet ws, const range_reference &ref, major_order order=major_order::row)``` #### ```cell xlnt::cell_vector::front()``` #### ```const cell xlnt::cell_vector::front() const``` #### ```cell xlnt::cell_vector::back()``` #### ```const cell xlnt::cell_vector::back() const``` #### ```cell xlnt::cell_vector::operator[](std::size_t column_index)``` #### ```const cell xlnt::cell_vector::operator[](std::size_t column_index) const``` #### ```std::size_t xlnt::cell_vector::length() const``` #### ```iterator xlnt::cell_vector::begin()``` #### ```iterator xlnt::cell_vector::end()``` #### ```const_iterator xlnt::cell_vector::begin() const``` #### ```const_iterator xlnt::cell_vector::cbegin() const``` #### ```const_iterator xlnt::cell_vector::end() const``` #### ```const_iterator xlnt::cell_vector::cend() const``` #### ```reverse_iterator xlnt::cell_vector::rbegin()``` #### ```reverse_iterator xlnt::cell_vector::rend()``` #### ```const_reverse_iterator xlnt::cell_vector::rbegin() const``` #### ```const_reverse_iterator xlnt::cell_vector::rend() const``` #### ```const_reverse_iterator xlnt::cell_vector::crbegin() const``` #### ```const_reverse_iterator xlnt::cell_vector::crend() const``` ### column_properties #### ```optional xlnt::column_properties::widthundefined``` #### ```bool xlnt::column_properties::custom_widthundefined``` #### ```optional xlnt::column_properties::styleundefined``` #### ```bool xlnt::column_properties::hiddenundefined``` ### const_cell_iterator #### ```xlnt::const_cell_iterator::const_cell_iterator(worksheet ws, const cell_reference &start_cell)``` #### ```xlnt::const_cell_iterator::const_cell_iterator(worksheet ws, const cell_reference &start_cell, major_order order)``` #### ```xlnt::const_cell_iterator::const_cell_iterator(const const_cell_iterator &other)``` #### ```const_cell_iterator& xlnt::const_cell_iterator::operator=(const const_cell_iterator &)=default``` #### ```const cell xlnt::const_cell_iterator::operator*() const``` #### ```bool xlnt::const_cell_iterator::operator==(const const_cell_iterator &other) const``` #### ```bool xlnt::const_cell_iterator::operator!=(const const_cell_iterator &other) const``` #### ```const_cell_iterator& xlnt::const_cell_iterator::operator--()``` #### ```const_cell_iterator xlnt::const_cell_iterator::operator--(int)``` #### ```const_cell_iterator& xlnt::const_cell_iterator::operator++()``` #### ```const_cell_iterator xlnt::const_cell_iterator::operator++(int)``` ### const_range_iterator #### ```xlnt::const_range_iterator::const_range_iterator(const worksheet &ws, const range_reference &start_cell, major_order order=major_order::row)``` #### ```xlnt::const_range_iterator::const_range_iterator(const const_range_iterator &other)``` #### ```const cell_vector xlnt::const_range_iterator::operator*() const``` #### ```const_range_iterator& xlnt::const_range_iterator::operator=(const const_range_iterator &)=default``` #### ```bool xlnt::const_range_iterator::operator==(const const_range_iterator &other) const``` #### ```bool xlnt::const_range_iterator::operator!=(const const_range_iterator &other) const``` #### ```const_range_iterator& xlnt::const_range_iterator::operator--()``` #### ```const_range_iterator xlnt::const_range_iterator::operator--(int)``` #### ```const_range_iterator& xlnt::const_range_iterator::operator++()``` #### ```const_range_iterator xlnt::const_range_iterator::operator++(int)``` ### 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()``` #### ```double xlnt::page_margins::top() const``` #### ```void xlnt::page_margins::top(double top)``` #### ```double xlnt::page_margins::left() const``` #### ```void xlnt::page_margins::left(double left)``` #### ```double xlnt::page_margins::bottom() const``` #### ```void xlnt::page_margins::bottom(double bottom)``` #### ```double xlnt::page_margins::right() const``` #### ```void xlnt::page_margins::right(double right)``` #### ```double xlnt::page_margins::header() const``` #### ```void xlnt::page_margins::header(double header)``` #### ```double xlnt::page_margins::footer() const``` #### ```void xlnt::page_margins::footer(double footer)``` ### page_setup #### ```xlnt::page_setup::page_setup()``` #### ```xlnt::page_break xlnt::page_setup::page_break() const``` #### ```void xlnt::page_setup::page_break(xlnt::page_break b)``` #### ```xlnt::sheet_state xlnt::page_setup::sheet_state() const``` #### ```void xlnt::page_setup::sheet_state(xlnt::sheet_state sheet_state)``` #### ```xlnt::paper_size xlnt::page_setup::paper_size() const``` #### ```void xlnt::page_setup::paper_size(xlnt::paper_size paper_size)``` #### ```xlnt::orientation xlnt::page_setup::orientation() const``` #### ```void xlnt::page_setup::orientation(xlnt::orientation orientation)``` #### ```bool xlnt::page_setup::fit_to_page() const``` #### ```void xlnt::page_setup::fit_to_page(bool fit_to_page)``` #### ```bool xlnt::page_setup::fit_to_height() const``` #### ```void xlnt::page_setup::fit_to_height(bool fit_to_height)``` #### ```bool xlnt::page_setup::fit_to_width() const``` #### ```void xlnt::page_setup::fit_to_width(bool fit_to_width)``` #### ```void xlnt::page_setup::horizontal_centered(bool horizontal_centered)``` #### ```bool xlnt::page_setup::horizontal_centered() const``` #### ```void xlnt::page_setup::vertical_centered(bool vertical_centered)``` #### ```bool xlnt::page_setup::vertical_centered() const``` #### ```void xlnt::page_setup::scale(double scale)``` #### ```double xlnt::page_setup::scale() const``` ### pane #### ```optional xlnt::pane::top_left_cellundefined``` #### ```pane_state xlnt::pane::stateundefined``` #### ```pane_corner xlnt::pane::active_paneundefined``` #### ```row_t xlnt::pane::y_splitundefined``` #### ```column_t xlnt::pane::x_splitundefined``` #### ```bool xlnt::pane::operator==(const pane &rhs) const``` ### range #### ```using xlnt::range::iterator = range_iteratorundefined``` #### ```using xlnt::range::const_iterator = const_range_iteratorundefined``` #### ```using xlnt::range::reverse_iterator = std::reverse_iteratorundefined``` #### ```using xlnt::range::const_reverse_iterator = std::reverse_iteratorundefined``` #### ```xlnt::range::range(worksheet ws, const range_reference &reference, major_order order=major_order::row, bool skip_null=false)``` #### ```xlnt::range::~range()``` #### ```xlnt::range::range(const range &)=default``` #### ```cell_vector xlnt::range::operator[](std::size_t vector_index)``` #### ```const cell_vector xlnt::range::operator[](std::size_t vector_index) const``` #### ```bool xlnt::range::operator==(const range &comparand) const``` #### ```bool xlnt::range::operator!=(const range &comparand) const``` #### ```cell_vector xlnt::range::vector(std::size_t vector_index)``` #### ```const cell_vector xlnt::range::vector(std::size_t vector_index) const``` #### ```class cell xlnt::range::cell(const cell_reference &ref)``` #### ```const class cell xlnt::range::cell(const cell_reference &ref) const``` #### ```range_reference xlnt::range::reference() const``` #### ```std::size_t xlnt::range::length() const``` #### ```bool xlnt::range::contains(const cell_reference &ref)``` #### ```iterator xlnt::range::begin()``` #### ```iterator xlnt::range::end()``` #### ```const_iterator xlnt::range::begin() const``` #### ```const_iterator xlnt::range::end() const``` #### ```const_iterator xlnt::range::cbegin() const``` #### ```const_iterator xlnt::range::cend() const``` #### ```reverse_iterator xlnt::range::rbegin()``` #### ```reverse_iterator xlnt::range::rend()``` #### ```const_reverse_iterator xlnt::range::rbegin() const``` #### ```const_reverse_iterator xlnt::range::rend() const``` #### ```const_reverse_iterator xlnt::range::crbegin() const``` #### ```const_reverse_iterator xlnt::range::crend() const``` ### range_iterator #### ```xlnt::range_iterator::range_iterator(worksheet &ws, const range_reference &start_cell, const range_reference &limits, major_order order=major_order::row)``` #### ```xlnt::range_iterator::range_iterator(const range_iterator &other)``` #### ```cell_vector xlnt::range_iterator::operator*() const``` #### ```range_iterator& xlnt::range_iterator::operator=(const range_iterator &)=default``` #### ```bool xlnt::range_iterator::operator==(const range_iterator &other) const``` #### ```bool xlnt::range_iterator::operator!=(const range_iterator &other) const``` #### ```range_iterator& xlnt::range_iterator::operator--()``` #### ```range_iterator xlnt::range_iterator::operator--(int)``` #### ```range_iterator& xlnt::range_iterator::operator++()``` #### ```range_iterator xlnt::range_iterator::operator++(int)``` ### range_reference #### ```static range_reference xlnt::range_reference::make_absolute(const range_reference &relative_reference)``` Convert a coordinate to an absolute coordinate string (B12 -> $B$12) #### ```xlnt::range_reference::range_reference()``` #### ```xlnt::range_reference::range_reference(const std::string &range_string)``` #### ```xlnt::range_reference::range_reference(const char *range_string)``` #### ```xlnt::range_reference::range_reference(const std::pair< cell_reference, cell_reference > &reference_pair)``` #### ```xlnt::range_reference::range_reference(const cell_reference &start, const cell_reference &end)``` #### ```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)``` #### ```bool xlnt::range_reference::is_single_cell() const``` #### ```std::size_t xlnt::range_reference::width() const``` #### ```std::size_t xlnt::range_reference::height() const``` #### ```cell_reference xlnt::range_reference::top_left() const``` #### ```cell_reference xlnt::range_reference::bottom_right() const``` #### ```cell_reference& xlnt::range_reference::top_left()``` #### ```cell_reference& xlnt::range_reference::bottom_right()``` #### ```range_reference xlnt::range_reference::make_offset(int column_offset, int row_offset) const``` #### ```std::string xlnt::range_reference::to_string() const``` #### ```bool xlnt::range_reference::operator==(const range_reference &comparand) const``` #### ```bool xlnt::range_reference::operator==(const std::string &reference_string) const``` #### ```bool xlnt::range_reference::operator==(const char *reference_string) const``` #### ```bool xlnt::range_reference::operator!=(const range_reference &comparand) const``` #### ```bool xlnt::range_reference::operator!=(const std::string &reference_string) const``` #### ```bool xlnt::range_reference::operator!=(const char *reference_string) const``` #### ```bool operator==(const std::string &reference_string, const range_reference &ref)``` #### ```bool operator==(const char *reference_string, const range_reference &ref)``` #### ```bool operator!=(const std::string &reference_string, const range_reference &ref)``` #### ```bool operator!=(const char *reference_string, const range_reference &ref)``` ### row_properties #### ```optional xlnt::row_properties::heightundefined``` #### ```bool xlnt::row_properties::custom_heightundefined``` #### ```bool xlnt::row_properties::hiddenundefined``` #### ```optional xlnt::row_properties::styleundefined``` ### selection #### ```bool xlnt::selection::has_active_cell() const``` #### ```cell_reference xlnt::selection::active_cell() const``` #### ```void xlnt::selection::active_cell(const cell_reference &ref)``` #### ```range_reference xlnt::selection::sqref() const``` #### ```pane_corner xlnt::selection::pane() const``` #### ```void xlnt::selection::pane(pane_corner corner)``` #### ```bool xlnt::selection::operator==(const selection &rhs) const``` ### sheet_protection #### ```static std::string xlnt::sheet_protection::hash_password(const std::string &password)``` #### ```void xlnt::sheet_protection::password(const std::string &password)``` #### ```std::string xlnt::sheet_protection::hashed_password() const``` ### sheet_view #### ```void xlnt::sheet_view::id(std::size_t new_id)``` #### ```std::size_t xlnt::sheet_view::id() const``` #### ```bool xlnt::sheet_view::has_pane() const``` #### ```struct pane& xlnt::sheet_view::pane()``` #### ```const struct pane& xlnt::sheet_view::pane() const``` #### ```void xlnt::sheet_view::clear_pane()``` #### ```void xlnt::sheet_view::pane(const struct pane &new_pane)``` #### ```bool xlnt::sheet_view::has_selections() const``` #### ```void xlnt::sheet_view::add_selection(const class selection &new_selection)``` #### ```void xlnt::sheet_view::clear_selections()``` #### ```std::vector xlnt::sheet_view::selections() const``` #### ```class xlnt::selection& xlnt::sheet_view::selection(std::size_t index)``` #### ```void xlnt::sheet_view::show_grid_lines(bool show)``` #### ```bool xlnt::sheet_view::show_grid_lines() const``` #### ```void xlnt::sheet_view::default_grid_color(bool is_default)``` #### ```bool xlnt::sheet_view::default_grid_color() const``` #### ```void xlnt::sheet_view::type(sheet_view_type new_type)``` #### ```sheet_view_type xlnt::sheet_view::type() const``` #### ```bool xlnt::sheet_view::operator==(const sheet_view &rhs) const``` ### 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_iteratorundefined``` Iterate in reverse over a non-const worksheet with an iterator of this type. #### ```using xlnt::worksheet::const_reverse_iterator = std::reverse_iteratorundefined``` Iterate in reverse order over a const worksheet with an iterator of this type. #### ```class range const cell_reference& xlnt::worksheet::bottom_rightundefined``` #### ```const class range const cell_reference& bottom_right xlnt::worksheet::constundefined``` #### ```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. #### ```class cell xlnt::worksheet::cell(column_t column, row_t row)``` #### ```const class cell xlnt::worksheet::cell(column_t column, row_t row) const``` #### ```class cell xlnt::worksheet::cell(const cell_reference &reference)``` #### ```const class cell xlnt::worksheet::cell(const cell_reference &reference) const``` #### ```bool xlnt::worksheet::has_cell(const cell_reference &reference) const``` #### ```class range xlnt::worksheet::range(const std::string &reference_string)``` #### ```class range xlnt::worksheet::range(const range_reference &reference)``` #### ```const class range xlnt::worksheet::range(const std::string &reference_string) const``` #### ```const class range xlnt::worksheet::range(const range_reference &reference) const``` #### ```class range xlnt::worksheet::rows() const``` #### ```class range xlnt::worksheet::rows(const std::string &range_string) const``` #### ```class range xlnt::worksheet::rows(int row_offset, int column_offset) const``` #### ```class range xlnt::worksheet::rows(const std::string &range_string, int row_offset, int column_offset) const``` #### ```class range xlnt::worksheet::columns() const``` #### ```xlnt::column_properties& xlnt::worksheet::column_properties(column_t column)``` #### ```const xlnt::column_properties& xlnt::worksheet::column_properties(column_t column) const``` #### ```bool xlnt::worksheet::has_column_properties(column_t column) const``` #### ```void xlnt::worksheet::add_column_properties(column_t column, const class column_properties &props)``` #### ```double xlnt::worksheet::column_width(column_t column) const``` Calculate 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)``` #### ```const xlnt::row_properties& xlnt::worksheet::row_properties(row_t row) const``` #### ```bool xlnt::worksheet::has_row_properties(row_t row) const``` #### ```void xlnt::worksheet::add_row_properties(row_t row, const class row_properties &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``` #### ```cell_reference xlnt::worksheet::point_pos(const std::pair< int, int > &point) const``` #### ```std::string xlnt::worksheet::unique_sheet_name(const std::string &value) const``` #### ```void xlnt::worksheet::create_named_range(const std::string &name, const std::string &reference_string)``` #### ```void xlnt::worksheet::create_named_range(const std::string &name, const range_reference &reference)``` #### ```bool xlnt::worksheet::has_named_range(const std::string &name)``` #### ```class range xlnt::worksheet::named_range(const std::string &name)``` #### ```void xlnt::worksheet::remove_named_range(const std::string &name)``` #### ```row_t xlnt::worksheet::lowest_row() const``` #### ```row_t xlnt::worksheet::highest_row() const``` #### ```row_t xlnt::worksheet::next_row() const``` #### ```column_t xlnt::worksheet::lowest_column() const``` #### ```column_t xlnt::worksheet::highest_column() const``` #### ```range_reference xlnt::worksheet::calculate_dimension() const``` #### ```void xlnt::worksheet::merge_cells(const std::string &reference_string)``` #### ```void xlnt::worksheet::merge_cells(const range_reference &reference)``` #### ```void xlnt::worksheet::merge_cells(column_t start_column, row_t start_row, column_t end_column, row_t end_row)``` #### ```void xlnt::worksheet::unmerge_cells(const std::string &reference_string)``` #### ```void xlnt::worksheet::unmerge_cells(const range_reference &reference)``` #### ```void xlnt::worksheet::unmerge_cells(column_t start_column, row_t start_row, column_t end_column, row_t end_row)``` #### ```std::vector xlnt::worksheet::merged_ranges() const``` #### ```void xlnt::worksheet::append()``` #### ```void xlnt::worksheet::append(const std::vector< std::string > &cells)``` #### ```void xlnt::worksheet::append(const std::vector< int > &cells)``` #### ```void xlnt::worksheet::append(const std::unordered_map< std::string, std::string > &cells)``` #### ```void xlnt::worksheet::append(const std::unordered_map< int, std::string > &cells)``` #### ```void xlnt::worksheet::append(const std::vector< int >::const_iterator begin, const std::vector< int >::const_iterator end)``` #### ```bool xlnt::worksheet::operator==(const worksheet &other) const``` #### ```bool xlnt::worksheet::operator!=(const worksheet &other) const``` #### ```bool xlnt::worksheet::operator==(std::nullptr_t) const``` #### ```bool xlnt::worksheet::operator!=(std::nullptr_t) const``` #### ```void xlnt::worksheet::operator=(const worksheet &other)``` #### ```class cell xlnt::worksheet::operator[](const cell_reference &reference)``` #### ```const class cell xlnt::worksheet::operator[](const cell_reference &reference) const``` #### ```class range xlnt::worksheet::operator[](const range_reference &reference)``` #### ```const class range xlnt::worksheet::operator[](const range_reference &reference) const``` #### ```class range xlnt::worksheet::operator[](const std::string &range_string)``` #### ```const class range xlnt::worksheet::operator[](const std::string &range_string) const``` #### ```class range xlnt::worksheet::operator()(const cell_reference &top_left``` #### ```const class range xlnt::worksheet::operator()(const cell_reference &top_left``` #### ```bool xlnt::worksheet::compare(const worksheet &other, bool reference) const``` #### ```bool xlnt::worksheet::has_page_setup() const``` #### ```xlnt::page_setup xlnt::worksheet::page_setup() const``` #### ```void xlnt::worksheet::page_setup(const struct page_setup &setup)``` #### ```bool xlnt::worksheet::has_page_margins() const``` #### ```xlnt::page_margins xlnt::worksheet::page_margins() const``` #### ```void xlnt::worksheet::page_margins(const class page_margins &margins)``` #### ```range_reference xlnt::worksheet::auto_filter() const``` #### ```void xlnt::worksheet::auto_filter(const std::string &range_string)``` #### ```void xlnt::worksheet::auto_filter(const xlnt::range &range)``` #### ```void xlnt::worksheet::auto_filter(const range_reference &reference)``` #### ```void xlnt::worksheet::clear_auto_filter()``` #### ```bool xlnt::worksheet::has_auto_filter() const``` #### ```void xlnt::worksheet::reserve(std::size_t n)``` #### ```bool xlnt::worksheet::has_header_footer() const``` #### ```class header_footer xlnt::worksheet::header_footer() const``` #### ```void xlnt::worksheet::header_footer(const class header_footer &new_header_footer)``` #### ```void xlnt::worksheet::parent(class workbook &wb)``` #### ```std::vector xlnt::worksheet::formula_attributes() const``` #### ```xlnt::sheet_state xlnt::worksheet::sheet_state() const``` #### ```void xlnt::worksheet::sheet_state(xlnt::sheet_state state)``` #### ```iterator xlnt::worksheet::begin()``` #### ```iterator xlnt::worksheet::end()``` #### ```const_iterator xlnt::worksheet::begin() const``` #### ```const_iterator xlnt::worksheet::end() const``` #### ```const_iterator xlnt::worksheet::cbegin() const``` #### ```const_iterator xlnt::worksheet::cend() const``` #### ```class range xlnt::worksheet::iter_cells(bool skip_null)``` #### ```void xlnt::worksheet::print_title_rows(row_t first_row, row_t last_row)``` #### ```void xlnt::worksheet::print_title_rows(row_t last_row)``` #### ```void xlnt::worksheet::print_title_cols(column_t first_column, column_t last_column)``` #### ```void xlnt::worksheet::print_title_cols(column_t last_column)``` #### ```std::string xlnt::worksheet::print_titles() const``` #### ```void xlnt::worksheet::print_area(const std::string &print_area)``` #### ```range_reference xlnt::worksheet::print_area() const``` #### ```bool xlnt::worksheet::has_view() const``` #### ```sheet_view xlnt::worksheet::view(std::size_t index=0) const``` #### ```void xlnt::worksheet::add_view(const sheet_view &new_view)``` #### ```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& 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& 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. ### worksheet_properties