xlnt/docs/source/includes/_api_reference.md

API Reference

Cell Module

cell

using xlnt::cell::type = cell_typeundefined

Alias xlnt::cell_type to xlnt::cell::type since it looks nicer.

friend class detail::xlsx_consumerundefined

friend class detail::xlsx_producerundefined

friend struct detail::cell_implundefined

static const std::unordered_map<std::string, int>& xlnt::cell::error_codes()

Returns a map of error strings such as #DIV/0! and their associated indices.

xlnt::cell::cell(const cell &)=default

Default copy constructor.

bool xlnt::cell::has_value() const

Returns true if value has been set and has not been cleared using cell::clear_value().

T xlnt::cell::value() const

Returns the value of this cell as an instance of type T. Overloads exist for most C++ fundamental types like bool, int, etc. as well as for std::string and xlnt datetime types: date, time, datetime, and timedelta.

void xlnt::cell::clear_value()

Makes this cell have a value of type null. All other cell attributes are retained.

void xlnt::cell::value(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<int, int> xlnt::cell::anchor() const

Returns the location of this cell as an ordered pair (left, top).

std::string xlnt::cell::hyperlink() const

Returns the URL of this cell's hyperlink.

void xlnt::cell::hyperlink(const std::string &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<std::string, row_t> 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<std::string, row_t> 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<rich_text_run> xlnt::rich_text::runs() const

Returns a copy of the individual runs that comprise this text.

void xlnt::rich_text::runs(const std::vector< rich_text_run > &new_runs)

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<path> xlnt::manifest::parts() const

Returns the path to all internal package parts registered as a source or target of a relationship.

bool xlnt::manifest::has_relationship(const path &source, relationship_type type) const

Returns true if the manifest contains a relationship with the given type with part as the source.

bool xlnt::manifest::has_relationship(const path &source, const std::string &rel_id) const

Returns true if the manifest contains a relationship with the given type with part as the source.

class relationship xlnt::manifest::relationship(const path &source, relationship_type type) const

Returns the relationship with "source" as the source and with a type of "type". Throws a key_not_found exception if no such relationship is found.

class relationship xlnt::manifest::relationship(const path &source, const std::string &rel_id) const

Returns the relationship with "source" as the source and with an ID of "rel_id". Throws a key_not_found exception if no such relationship is found.

std::vector<xlnt::relationship> xlnt::manifest::relationships(const path &source) const

Returns all relationship with "source" as the source.

std::vector<xlnt::relationship> xlnt::manifest::relationships(const path &source, relationship_type type) const

Returns all relationships with "source" as the source and with a type of "type".

path xlnt::manifest::canonicalize(const std::vector< xlnt::relationship > &rels) const

Returns the canonical path of the chain of relationships by traversing through rels and forming the absolute combined path.

std::string xlnt::manifest::register_relationship(const uri &source, relationship_type type, const uri &target, target_mode mode)

std::string xlnt::manifest::register_relationship(const class relationship &rel)

std::unordered_map<std::string, std::string> xlnt::manifest::unregister_relationship(const uri &source, const std::string &rel_id)

Delete the relationship with the given id from source part. Returns a mapping of relationship IDs since IDs are shifted down. For example, if there are three relationships for part a.xml like [rId1, rId2, rId3] and rId2 is deleted, the resulting map would look like [rId3->rId2].

std::string xlnt::manifest::content_type(const path &part) const

Given the path to a part, returns the content type of the part as a string.

bool xlnt::manifest::has_default_type(const std::string &extension) const

Returns true if a default content type for the extension has been registered.

std::vector<std::string> xlnt::manifest::extensions_with_default_types() const

Returns a vector of all extensions with registered default content types.

std::string xlnt::manifest::default_type(const std::string &extension) const

Returns the registered default content type for parts of the given extension.

void xlnt::manifest::register_default_type(const std::string &extension, const std::string &type)

Associates the given extension with the given content type.

void xlnt::manifest::unregister_default_type(const std::string &extension)

Unregisters the default content type for the given extension.

bool xlnt::manifest::has_override_type(const path &part) const

Returns true if a content type overriding the default content type has been registered for the given part.

std::string xlnt::manifest::override_type(const path &part) const

Returns the override content type registered for the given part. Throws key_not_found exception if no override type was found.

std::vector<path> xlnt::manifest::parts_with_overriden_types() const

Returns the path of every part in this manifest with an overriden content type.

void xlnt::manifest::register_override_type(const path &part, const std::string &type)

Overrides any default type registered for the part's extension with the given content type.

void xlnt::manifest::unregister_override_type(const path &part)

Unregisters the overriding content type of the given part.

relationship

xlnt::relationship::relationship()

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<int> xlnt::alignment::indent() const

alignment& xlnt::alignment::indent(int indent_size)

optional<int> xlnt::alignment::rotation() const

alignment& xlnt::alignment::rotation(int text_rotation)

optional<horizontal_alignment> xlnt::alignment::horizontal() const

alignment& xlnt::alignment::horizontal(horizontal_alignment horizontal)

optional<vertical_alignment> 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<border_side>& xlnt::border::all_sides()

xlnt::border::border()

optional<border_property> xlnt::border::side(border_side s) const

border& xlnt::border::side(border_side s, const border_property &prop)

optional<diagonal_direction> 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<class color> xlnt::border::border_property::color() const

border_property& xlnt::border::border_property::color(const xlnt::color &c)

optional<border_style> 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<std::uint8_t, 3> xlnt::rgb_color::rgb() const

std::array<std::uint8_t, 4> 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<color> xlnt::pattern_fill::foreground() const

pattern_fill& xlnt::pattern_fill::foreground(const color &foreground)

optional<color> 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<double, color> 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<bool> xlnt::style::custom() const

style xlnt::style::custom(bool value)

optional<std::size_t> 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<std::string, std::string> xlnt::path::split_extension() const

Return a pair of strings resulting from splitting the filename on the last dot.

std::vector<std::string> xlnt::path::split() const

Create a string representing this path separated by the provided separator or the system-default separator if not provided.

std::string xlnt::path::string() const

Create a string representing this path separated by the provided separator or the system-default separator if not provided.

path xlnt::path::resolve(const path &base_path) const

If this path is relative, append each component of this path to base_path and return the resulting absolute path. Otherwise, the the current path will be returned and base_path will be ignored.

path xlnt::path::relative_to(const path &base_path) const

The inverse of path::resolve. Creates a relative path from an absolute path by removing the common root between base_path and this path. If the current path is already relative, return it unchanged.

bool xlnt::path::exists() const

Return true iff the file or directory pointed to by this path exists on the filesystem.

bool xlnt::path::is_directory() const

Return true if the file or directory pointed to by this path is a directory.

bool xlnt::path::is_file() const

Return true if the file or directory pointed to by this path is a regular file.

std::string xlnt::path::read_contents() const

Open the file pointed to by this path and return a string containing the files contents.

path xlnt::path::append(const std::string &to_append) const

Append the provided part to this path and return the result.

path xlnt::path::append(const path &to_append) const

Append the provided part to this path and return the result.

bool 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::pair<worksheet, range_reference>undefined

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<target>& 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_iterator<iterator>undefined

typedef for the iterator used for iterating through this workbook (non-const) in a range-based for loop in reverse order using std::make_reverse_iterator.

using xlnt::workbook::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined

typedef for the iterator used for iterating through this workbook (const) in a range-based for loop in reverse order using std::make_reverse_iterator.

friend class detail::xlsx_consumerundefined

friend class detail::xlsx_producerundefined

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<std::string> xlnt::workbook::sheet_titles() const

Returns a temporary vector containing the titles of each sheet in the order of the sheets in the workbook.

std::size_t xlnt::workbook::sheet_count() const

Returns the number of sheets in this workbook.

bool xlnt::workbook::has_core_property(xlnt::core_property type) const

Returns true if the workbook has the core property with the given name.

std::vector<xlnt::core_property> xlnt::workbook::core_properties() const

Returns a vector of the type of each core property that is set to a particular value in this workbook.

variant xlnt::workbook::core_property(xlnt::core_property type) const

Returns the value of the given core property.

void xlnt::workbook::core_property(xlnt::core_property type, const variant &value)

Sets the given core property to the provided value.

bool xlnt::workbook::has_extended_property(xlnt::extended_property type) const

Returns true if the workbook has the extended property with the given name.

std::vector<xlnt::extended_property> xlnt::workbook::extended_properties() const

Returns a vector of the type of each extended property that is set to a particular value in this workbook.

variant xlnt::workbook::extended_property(xlnt::extended_property type) const

Returns the value of the given extended property.

void xlnt::workbook::extended_property(xlnt::extended_property type, const variant &value)

Sets the given extended property to the provided value.

bool xlnt::workbook::has_custom_property(const std::string &property_name) const

Returns true if the workbook has the custom property with the given name.

std::vector<std::string> xlnt::workbook::custom_properties() const

Returns a vector of the name of each custom property that is set to a particular value in this workbook.

variant xlnt::workbook::custom_property(const std::string &property_name) const

Returns the value of the given custom property.

void xlnt::workbook::custom_property(const std::string &property_name, const variant &value)

Creates a new custom property in this workbook and sets it to the provided value.

calendar xlnt::workbook::base_date() const

Returns the base date used by this workbook. This will generally be windows_1900 except on Apple based systems when it will default to mac_1904 unless otherwise set via void workbook::base_date(calendar base_date).

void xlnt::workbook::base_date(calendar base_date)

Sets the base date style of this workbook. This is the date and time that a numeric value of 0 represents.

bool xlnt::workbook::has_title() const

Returns true if this workbook has had its title set.

std::string xlnt::workbook::title() const

Returns the title of this workbook.

void xlnt::workbook::title(const std::string &title)

Sets the title of this workbook to title.

std::vector<xlnt::named_range> xlnt::workbook::named_ranges() const

Returns a vector of the named ranges in this workbook.

void xlnt::workbook::create_named_range(const std::string &name, worksheet worksheet, const range_reference &reference)

Creates a new names range.

void xlnt::workbook::create_named_range(const std::string &name, worksheet worksheet, const std::string &reference_string)

Creates a new names range.

bool xlnt::workbook::has_named_range(const std::string &name) const

Returns true if a named range of the given name exists in the workbook.

class range xlnt::workbook::named_range(const std::string &name)

Returns the named range with the given name.

void xlnt::workbook::remove_named_range(const std::string &name)

Deletes the named range with the given name.

void xlnt::workbook::save(std::vector< std::uint8_t > &data) const

Serializes the workbook into an XLSX file and saves the bytes into byte vector data.

void xlnt::workbook::save(std::vector< std::uint8_t > &data, const std::string &password) const

Serializes the workbook into an XLSX file encrypted with the given password and saves the bytes into byte vector data.

void xlnt::workbook::save(const std::string &filename) const

Serializes the workbook into an XLSX file and saves the data into a file named filename.

void xlnt::workbook::save(const std::string &filename, const std::string &password)

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<rich_text>& xlnt::workbook::shared_strings()

Returns a reference to the shared strings being used by cells in this workbook.

const std::vector<rich_text>& xlnt::workbook::shared_strings() const

Returns a reference to the shared strings being used by cells in this workbook.

void xlnt::workbook::thumbnail(const std::vector< std::uint8_t > &thumbnail, const std::string &extension, const std::string &content_type)

Sets the workbook's thumbnail to the given vector of bytes, thumbnail, with the given extension (e.g. jpg) and content_type (e.g. image/jpeg).

const std::vector<std::uint8_t>& xlnt::workbook::thumbnail() const

Returns a vector of bytes representing the workbook's thumbnail.

bool xlnt::workbook::has_calculation_properties() const

Returns true if this workbook has any calculation properties set.

class calculation_properties xlnt::workbook::calculation_properties() const

Returns the calculation properties used in this workbook.

void xlnt::workbook::calculation_properties(const class calculation_properties &props)

Sets the calculation properties of this workbook to props.

workbook& xlnt::workbook::operator=(workbook other)

Set the contents of this workbook to be equal to those of "other". Other is passed as value to allow for copy-swap idiom.

worksheet xlnt::workbook::operator[](const std::string &name)

Return the worksheet with a title of "name".

worksheet xlnt::workbook::operator[](std::size_t index)

Return the worksheet at "index".

bool xlnt::workbook::operator==(const workbook &rhs) const

Return true if this workbook internal implementation points to the same memory as rhs's.

bool xlnt::workbook::operator!=(const workbook &rhs) const

Return true if this workbook internal implementation doesn't point to the same memory as rhs's.

workbook_view

bool xlnt::workbook_view::auto_filter_date_groupingundefined

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<std::size_t> xlnt::workbook_view::active_tabundefined

optional<std::size_t> xlnt::workbook_view::first_sheetundefined

optional<std::size_t> xlnt::workbook_view::tab_ratioundefined

optional<std::size_t> xlnt::workbook_view::window_widthundefined

optional<std::size_t> xlnt::workbook_view::window_heightundefined

optional<std::size_t> xlnt::workbook_view::x_windowundefined

optional<std::size_t> 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_iterator<iterator>undefined

using xlnt::cell_vector::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined

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<double> xlnt::column_properties::widthundefined

bool xlnt::column_properties::custom_widthundefined

optional<std::size_t> 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<cell_reference> 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_iterator<iterator>undefined

using xlnt::range::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined

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<double> xlnt::row_properties::heightundefined

bool xlnt::row_properties::custom_heightundefined

bool xlnt::row_properties::hiddenundefined

optional<std::size_t> 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::selection> 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_iterator<iterator>undefined

Iterate in reverse over a non-const worksheet with an iterator of this type.

using xlnt::worksheet::const_reverse_iterator = std::reverse_iterator<const_iterator>undefined

Iterate in reverse order over a const worksheet with an iterator of this type.

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<range_reference> 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<std::string> 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<row_t>& xlnt::worksheet::page_break_rows() const

Returns vector where each element represents a row which will break a page below it.

void xlnt::worksheet::page_break_at_row(row_t row)

Add a page break at the given row.

const std::vector<column_t>& xlnt::worksheet::page_break_columns() const

Returns vector where each element represents a column which will break a page to the right.

void xlnt::worksheet::page_break_at_column(column_t column)

Add a page break at the given column.

worksheet_properties