xlnt/source/xlnt.cpp
2014-05-11 20:52:32 -04:00

1313 lines
31 KiB
C++

#include <algorithm>
#include <array>
#include <fstream>
#include <iostream>
#include <sstream>
#include "xlnt.h"
namespace xlnt {
namespace {
class not_implemented : public std::runtime_error
{
public:
not_implemented() : std::runtime_error("error: not implemented")
{
}
};
} // namespace
#ifdef _WIN32
#include <Windows.h>
void file::copy(const std::string &source, const std::string &destination, bool overwrite)
{
assert(source.size() + 1 < MAX_PATH);
assert(destination.size() + 1 < MAX_PATH);
std::wstring source_wide(source.begin(), source.end());
std::wstring destination_wide(destination.begin(), destination.end());
BOOL result = CopyFile(source_wide.c_str(), destination_wide.c_str(), !overwrite);
if(result == 0)
{
DWORD error = GetLastError();
switch(GetLastError())
{
case ERROR_ACCESS_DENIED: throw std::runtime_error("Access is denied");
case ERROR_ENCRYPTION_FAILED: throw std::runtime_error("The specified file could not be encrypted");
case ERROR_FILE_NOT_FOUND: throw std::runtime_error("The source file wasn't found");
default:
if(!overwrite)
{
throw std::runtime_error("The destination file already exists");
}
throw std::runtime_error("Unknown error");
}
}
}
bool file::exists(const std::string &path)
{
std::wstring path_wide(path.begin(), path.end());
return PathFileExists(path_wide.c_str()) && !PathIsDirectory(path_wide.c_str());
}
#else
#include <sys/stat.h>
void file::copy(const std::string &source, const std::string &destination, bool overwrite)
{
if(!overwrite && exists(destination))
{
throw std::runtime_error("destination file already exists and overwrite==false");
}
std::ifstream src(source, std::ios::binary);
std::ofstream dst(destination, std::ios::binary);
dst << src.rdbuf();
}
bool file::exists(const std::string &path)
{
struct stat fileAtt;
if (stat(path.c_str(), &fileAtt) != 0)
{
throw std::runtime_error("stat failed");
}
return S_ISREG(fileAtt.st_mode);
}
#endif //_WIN32
struct part_struct
{
part_struct(package_impl &package, const std::string &uri_part, const std::string &mime_type = "", compression_option compression = compression_option::NotCompressed)
: compression_option_(compression),
content_type_(mime_type),
package_(package),
uri_(uri_part)
{}
part_struct(package_impl &package, const std::string &uri, opcContainer *container)
: package_(package),
uri_(uri),
container_(container)
{}
relationship create_relationship(const std::string &target_uri, target_mode target_mode, const std::string &relationship_type);
void delete_relationship(const std::string &id);
relationship get_relationship(const std::string &id);
relationship_collection get_relationships();
relationship_collection get_relationship_by_type(const std::string &relationship_type);
std::string read()
{
std::string ss;
auto part_stream = opcContainerOpenInputStream(container_, (xmlChar*)uri_.c_str());
std::array<xmlChar, 1024> buffer;
auto bytes_read = opcContainerReadInputStream(part_stream, buffer.data(), static_cast<opc_uint32_t>(buffer.size()));
if(bytes_read > 0)
{
ss.append(std::string(buffer.begin(), buffer.begin() + bytes_read));
while(bytes_read == buffer.size())
{
auto bytes_read = opcContainerReadInputStream(part_stream, buffer.data(), static_cast<opc_uint32_t>(buffer.size()));
ss.append(std::string(buffer.begin(), buffer.begin() + bytes_read));
}
}
opcContainerCloseInputStream(part_stream);
return ss;
}
void write(const std::string &data)
{
auto name = uri_;
auto name_pointer = name.c_str();
auto part_stream = opcContainerCreateOutputStream(container_, (xmlChar*)name_pointer, opcCompressionOption_t::OPC_COMPRESSIONOPTION_NORMAL);
std::stringstream ss(data);
std::array<xmlChar, 1024> buffer;
while(ss)
{
ss.get((char*)buffer.data(), 1024);
auto count = ss.gcount();
if(count > 0)
{
opcContainerWriteOutputStream(part_stream, buffer.data(), static_cast<opc_uint32_t>(count));
}
}
opcContainerCloseOutputStream(part_stream);
}
/// <summary>
/// Returns a value that indicates whether this part owns a relationship with a specified Id.
/// </summary>
bool relationship_exists(const std::string &id) const;
/// <summary>
/// Returns true if the given Id string is a valid relationship identifier.
/// </summary>
bool is_valid_xml_id(const std::string &id);
void operator=(const part_struct &other);
compression_option compression_option_;
std::string content_type_;
package_impl &package_;
std::string uri_;
opcContainer *container_;
};
part::part(package_impl &package, const std::string &uri, opcContainer *container)
: root_(new part_struct(package, uri, container))
{
}
part::part(part_struct *root) : root_(root)
{
}
std::string part::get_content_type() const
{
return "";
}
std::string part::read()
{
if(root_ == nullptr)
{
return "";
}
return root_->read();
}
void part::write(const std::string &data)
{
if(root_ == nullptr)
{
return;
}
return root_->write(data);
}
bool part::operator==(const part &comparand) const
{
return root_ == comparand.root_;
}
bool part::operator==(const std::nullptr_t &) const
{
return root_ == nullptr;
}
struct package_impl
{
package *parent_;
opcContainer *opc_container_;
std::iostream &stream_;
std::fstream file_stream_;
file_mode package_mode_;
file_access package_access_;
std::vector<xmlChar> container_buffer_;
bool open_;
bool streaming_;
file_access get_file_open_access() const
{
if(!open_)
{
throw std::runtime_error("The package is not open");
}
return package_access_;
}
package_impl(std::iostream &stream, file_mode package_mode, file_access package_access)
: stream_(stream),
package_mode_(package_mode),
package_access_(package_access),
container_buffer_(4096)
{
open_container();
}
package_impl(const std::string &path, file_mode package_mode, file_access package_access)
: stream_(file_stream_),
package_mode_(package_mode),
package_access_(package_access),
container_buffer_(4096)
{
switch(package_mode)
{
case file_mode::Append:
switch(package_access)
{
case file_access::Read: throw std::runtime_error("Append can only be used with file_access.Write");
case file_access::ReadWrite: throw std::runtime_error("Append can only be used with file_access.Write");
case file_access::Write:
file_stream_.open(path, std::ios::binary | std::ios::app | std::ios::out);
break;
default: throw std::runtime_error("invalid access");
}
break;
case file_mode::Create:
switch(package_access)
{
case file_access::Read:
file_stream_.open(path, std::ios::binary | std::ios::in);
break;
case file_access::ReadWrite:
file_stream_.open(path, std::ios::binary | std::ios::in | std::ios::out);
break;
case file_access::Write:
file_stream_.open(path, std::ios::binary | std::ios::out);
break;
default: throw std::runtime_error("invalid access");
}
break;
case file_mode::CreateNew:
if(!file::exists(path))
{
throw std::runtime_error("File already exists");
}
switch(package_access)
{
case file_access::Read:
file_stream_.open(path, std::ios::binary | std::ios::in);
break;
case file_access::ReadWrite:
file_stream_.open(path, std::ios::binary | std::ios::in | std::ios::out);
break;
case file_access::Write:
file_stream_.open(path, std::ios::binary | std::ios::out);
break;
default: throw std::runtime_error("invalid access");
}
break;
case file_mode::Open:
if(!file::exists(path))
{
throw std::runtime_error("Can't open non-existent file");
}
switch(package_access)
{
case file_access::Read:
file_stream_.open(path, std::ios::binary | std::ios::in);
break;
case file_access::ReadWrite:
file_stream_.open(path, std::ios::binary | std::ios::in | std::ios::out);
break;
case file_access::Write:
file_stream_.open(path, std::ios::binary | std::ios::out);
break;
default: throw std::runtime_error("invalid access");
}
break;
case file_mode::OpenOrCreate:
switch(package_access)
{
case file_access::Read:
file_stream_.open(path, std::ios::binary | std::ios::in);
break;
case file_access::ReadWrite:
file_stream_.open(path, std::ios::binary | std::ios::in | std::ios::out);
break;
case file_access::Write:
file_stream_.open(path, std::ios::binary | std::ios::out);
break;
default: throw std::runtime_error("invalid access");
}
break;
case file_mode::Truncate:
if(!file::exists(path))
{
throw std::runtime_error("Can't truncate non-existent file");
}
switch(package_access)
{
case file_access::Read:
file_stream_.open(path, std::ios::binary | std::ios::trunc | std::ios::in);
break;
case file_access::ReadWrite:
file_stream_.open(path, std::ios::binary | std::ios::trunc | std::ios::in | std::ios::out);
break;
case file_access::Write:
file_stream_.open(path, std::ios::binary | std::ios::trunc | std::ios::out);
break;
default: throw std::runtime_error("invalid access");
}
break;
}
open_container();
}
void open_container()
{
opcContainerOpenMode m;
switch(package_access_)
{
case file_access::Read:
m = opcContainerOpenMode::OPC_OPEN_READ_ONLY;
break;
case file_access::ReadWrite:
m = opcContainerOpenMode::OPC_OPEN_READ_WRITE;
break;
case file_access::Write:
m = opcContainerOpenMode::OPC_OPEN_WRITE_ONLY;
break;
default:
throw std::runtime_error("unknown file access");
}
opc_container_ = opcContainerOpenIO(&read_callback, &write_callback,
&close_callback, &seek_callback,
&trim_callback, &flush_callback, this, 4096, m, this);
open_ = true;
}
~package_impl()
{
close();
}
void close()
{
if(open_)
{
open_ = false;
opcContainerClose(opc_container_, opcContainerCloseMode::OPC_CLOSE_NOW);
opc_container_ = nullptr;
}
}
part create_part(const std::string &part_uri, const std::string &/*content_type*/, compression_option /*compression*/)
{
return part(new part_struct(*this, part_uri, opc_container_));
}
void delete_part(const std::string &/*part_uri*/)
{
}
void flush()
{
stream_.flush();
}
part get_part(const std::string &part_uri)
{
return part(*this, part_uri, opc_container_);
}
part_collection get_parts()
{
return part_collection();
}
int write(char *buffer, int length)
{
stream_.read(buffer, length);
auto bytes_read = stream_.gcount();
return static_cast<int>(bytes_read);
}
int read(const char *buffer, int length)
{
auto before = stream_.tellp();
stream_.write(buffer, length);
auto bytes_written = stream_.tellp() - before;
return static_cast<int>(bytes_written);
}
std::ios::pos_type seek(std::ios::pos_type offset)
{
stream_.clear();
stream_.seekg(offset);
auto current_position = stream_.tellg();
if(stream_.eof())
{
std::cout << "eof" << std::endl;
}
if(stream_.fail())
{
std::cout << "fail" << std::endl;
}
if(stream_.bad())
{
std::cout << "bad" << std::endl;
}
return current_position;
}
int trim(std::ios::pos_type /*new_size*/)
{
return 0;
}
static int read_callback(void *context, char *buffer, int length)
{
auto object = static_cast<package_impl *>(context);
return object->write(buffer, length);
}
static int write_callback(void *context, const char *buffer, int length)
{
auto object = static_cast<package_impl *>(context);
return object->read(buffer, length);
}
static int close_callback(void *context)
{
auto object = static_cast<package_impl *>(context);
object->close();
return 0;
}
static opc_ofs_t seek_callback(void *context, opc_ofs_t ofs)
{
auto object = static_cast<package_impl *>(context);
return static_cast<opc_ofs_t>(object->seek(ofs));
}
static int trim_callback(void *context, opc_ofs_t new_size)
{
auto object = static_cast<package_impl *>(context);
return object->trim(new_size);
}
static int flush_callback(void *context)
{
auto object = static_cast<package_impl *>(context);
object->flush();
return 0;
}
};
file_access package::get_file_open_access() const
{
return impl_->get_file_open_access();
}
package package::open(std::iostream &stream, file_mode package_mode, file_access package_access)
{
return package(stream, package_mode, package_access);
}
package package::open(const std::string &path, file_mode package_mode, file_access package_access, file_share /*package_share*/)
{
return package(path, package_mode, package_access);
}
package::package(std::iostream &stream, file_mode package_mode, file_access package_access)
: impl_(new package_impl(stream, package_mode, package_access))
{
open_container();
}
package::package(const std::string &path, file_mode package_mode, file_access package_access)
: impl_(new package_impl(path, package_mode, package_access))
{
}
void package::open_container()
{
impl_->open_container();
}
void package::close()
{
impl_->close();
}
part package::create_part(const std::string &part_uri, const std::string &content_type, compression_option compression)
{
return impl_->create_part(part_uri, content_type, compression);
}
void package::delete_part(const std::string &part_uri)
{
impl_->delete_part(part_uri);
}
void package::flush()
{
impl_->flush();
}
part package::get_part(const std::string &part_uri)
{
return impl_->get_part(part_uri);
}
part_collection package::get_parts()
{
return impl_->get_parts();
}
int package::write(char *buffer, int length)
{
return impl_->write(buffer, length);
}
int package::read(const char *buffer, int length)
{
return impl_->read(buffer, length);
}
std::ios::pos_type package::seek(std::ios::pos_type offset)
{
return impl_->seek(offset);
}
int package::trim(std::ios::pos_type new_size)
{
return impl_->trim(new_size);
}
bool package::operator==(const package &comparand) const
{
return impl_ == comparand.impl_;
}
bool package::operator==(const std::nullptr_t &) const
{
return impl_ == nullptr;
}
struct cell_struct
{
cell_struct(worksheet_struct *ws, const std::string &column, int row)
: type(cell::type::null), parent_worksheet(ws),
column(xlnt::cell::column_index_from_string(column) - 1), row(row)
{
}
std::string to_string() const;
cell::type type;
union
{
long double numeric_value;
bool bool_value;
};
tm date_value;
std::string string_value;
std::string formula_value;
worksheet_struct *parent_worksheet;
int column;
int row;
};
cell::cell() : root_(nullptr)
{
}
cell::cell(worksheet &worksheet, const std::string &column, int row) : root_(nullptr)
{
cell self = worksheet.cell(column + std::to_string(row));
root_ = self.root_;
}
cell::cell(worksheet &worksheet, const std::string &column, int row, const std::string &initial_value) : root_(nullptr)
{
cell self = worksheet.cell(column + std::to_string(row));
root_ = self.root_;
*this = initial_value;
}
cell::cell(cell_struct *root) : root_(root)
{
}
coordinate cell::coordinate_from_string(const std::string &coord_string)
{
// Convert a coordinate string like 'B12' to a tuple ('B', 12)
bool column_part = true;
coordinate result;
for(auto character : coord_string)
{
char upper = std::toupper(character);
if(std::isalpha(character))
{
if(column_part)
{
result.column.append(1, upper);
}
else
{
std::string msg = "Invalid cell coordinates (" + coord_string + ")";
throw std::runtime_error(msg);
}
}
else
{
if(column_part)
{
column_part = false;
}
else if(!(std::isdigit(character) || character == '$'))
{
std::string msg = "Invalid cell coordinates (" + coord_string + ")";
throw std::runtime_error(msg);
}
}
}
std::string row_string = coord_string.substr(result.column.length());
if(row_string[0] == '$')
{
row_string = row_string.substr(1);
}
result.row = std::stoi(row_string);
if(result.row < 1)
{
std::string msg = "Invalid cell coordinates (" + coord_string + ")";
throw std::runtime_error(msg);
}
return result;
}
int cell::column_index_from_string(const std::string &column_string)
{
if(column_string.length() > 3 || column_string.empty())
{
throw std::runtime_error("column must be one to three characters");
}
int column_index = 0;
int place = 1;
for(int i = column_string.length() - 1; i >= 0; i--)
{
if(!std::isalpha(column_string[i]))
{
throw std::runtime_error("column must contain only letters in the range A-Z");
}
column_index += (std::toupper(column_string[i]) - 'A' + 1) * place;
place *= 26;
}
return column_index;
}
// Convert a column number into a column letter (3 -> 'C')
// Right shift the column col_idx by 26 to find column letters in reverse
// order.These numbers are 1 - based, and can be converted to ASCII
// ordinals by adding 64.
std::string cell::get_column_letter(int column_index)
{
// these indicies corrospond to A->ZZZ and include all allowed
// columns
if(column_index < 1 || column_index > 18278)
{
auto msg = "Column index out of bounds: " + std::to_string(column_index);
throw std::runtime_error(msg);
}
auto temp = column_index;
std::string column_letter = "";
while(temp > 0)
{
int quotient = temp / 26, remainder = temp % 26;
// check for exact division and borrow if needed
if(remainder == 0)
{
quotient -= 1;
remainder = 26;
}
column_letter = std::string(1, char(remainder + 64)) + column_letter;
temp = quotient;
}
return column_letter;
}
bool cell::is_date() const
{
return root_->type == type::date;
}
bool operator==(const char *comparand, const cell &cell)
{
return std::string(comparand) == cell;
}
bool operator==(const std::string &comparand, const cell &cell)
{
return cell.root_->type == cell::type::string && cell.root_->string_value == comparand;
}
bool operator==(const tm &comparand, const cell &cell)
{
return cell.root_->type == cell::type::date && cell.root_->date_value.tm_hour == comparand.tm_hour;
}
std::string cell::absolute_coordinate(const std::string &absolute_address)
{
// Convert a coordinate to an absolute coordinate string (B12 -> $B$12)
auto colon_index = absolute_address.find(':');
if(colon_index != std::string::npos)
{
return absolute_coordinate(absolute_address.substr(0, colon_index)) + ":"
+ absolute_coordinate(absolute_address.substr(colon_index + 1));
}
else
{
auto coord = coordinate_from_string(absolute_address);
return std::string("$") + coord.column + "$" + std::to_string(coord.row);
}
}
cell::type cell::get_data_type()
{
return root_->type;
}
cell &cell::operator=(int value)
{
root_->type = type::numeric;
root_->numeric_value = value;
return *this;
}
cell &cell::operator=(double value)
{
root_->type = type::numeric;
root_->numeric_value = value;
return *this;
}
cell &cell::operator=(bool value)
{
root_->type = type::boolean;
root_->bool_value = value;
return *this;
}
cell &cell::operator=(const std::string &value)
{
if(value == "")
{
root_->type = type::null;
return *this;
}
if(value[0] == '=')
{
root_->type = type::formula;
root_->formula_value = value;
return *this;
}
if(value[0] == '0')
{
if(value.length() > 1)
{
if(value[1] == '.')
{
try
{
double double_value = std::stod(value);
*this = double_value;
return *this;
}
catch(std::invalid_argument)
{
}
}
}
else
{
root_->type = type::numeric;
root_->numeric_value = 0;
return *this;
}
root_->type = type::string;
root_->string_value = value;
return *this;
}
try
{
double double_value = std::stod(value);
*this = double_value;
}
catch(std::invalid_argument)
{
root_->type = type::string;
root_->string_value = value;
}
return *this;
}
cell &cell::operator=(const char *value)
{
return *this = std::string(value);
}
cell &cell::operator=(const tm &value)
{
root_->type = type::date;
root_->date_value = value;
return *this;
}
std::string cell::to_string() const
{
return root_->to_string();
}
struct worksheet_struct
{
worksheet_struct(workbook &parent_workbook, const std::string &title)
: parent_(parent_workbook), title_(title), freeze_panes_(nullptr)
{
}
void garbage_collect()
{
throw not_implemented();
}
std::set<cell> get_cell_collection()
{
throw not_implemented();
}
std::string get_title() const
{
throw not_implemented();
}
void set_title(const std::string &title)
{
title_ = title;
}
cell get_freeze_panes() const
{
return freeze_panes_;
}
void set_freeze_panes(cell top_left_cell)
{
freeze_panes_ = top_left_cell;
}
void set_freeze_panes(const std::string &top_left_coordinate)
{
freeze_panes_ = cell(top_left_coordinate);
}
void unfreeze_panes()
{
freeze_panes_ = xlnt::cell(nullptr);
}
xlnt::cell cell(const std::string &coordinate)
{
if(cell_map_.find(coordinate) == cell_map_.end())
{
auto coord = xlnt::cell::coordinate_from_string(coordinate);
cell_struct *cell = new xlnt::cell_struct(this, coord.column, coord.row);
cell_map_[coordinate] = xlnt::cell(cell);
}
return cell_map_[coordinate];
}
xlnt::cell cell(int row, int column)
{
return cell(xlnt::cell::get_column_letter(column + 1) + std::to_string(row + 1));
}
int get_highest_row() const
{
throw not_implemented();
}
int get_highest_column() const
{
throw not_implemented();
}
std::string calculate_dimension() const
{
throw not_implemented();
}
range range(const std::string &range_string, int /*row_offset*/, int /*column_offset*/)
{
auto colon_index = range_string.find(':');
if(colon_index != std::string::npos)
{
auto min_range = range_string.substr(0, colon_index);
auto max_range = range_string.substr(colon_index + 1);
xlnt::range r;
r.push_back(std::vector<xlnt::cell>());
r[0].push_back(cell(min_range));
r[0].push_back(cell(max_range));
return r;
}
throw not_implemented();
}
relationship create_relationship(const std::string &relationship_type)
{
relationships_.push_back(relationship(relationship_type));
return relationships_.back();
}
//void add_chart(chart chart);
void merge_cells(const std::string &/*range_string*/)
{
throw not_implemented();
}
void merge_cells(int /*start_row*/, int /*start_column*/, int /*end_row*/, int /*end_column*/)
{
throw not_implemented();
}
void unmerge_cells(const std::string &/*range_string*/)
{
throw not_implemented();
}
void unmerge_cells(int /*start_row*/, int /*start_column*/, int /*end_row*/, int /*end_column*/)
{
throw not_implemented();
}
void append(const std::vector<xlnt::cell> &cells)
{
for(auto cell : cells)
{
cell_map_["a"] = cell;
}
}
void append(const std::unordered_map<std::string, xlnt::cell> &cells)
{
for(auto cell : cells)
{
cell_map_[cell.first] = cell.second;
}
}
void append(const std::unordered_map<int, xlnt::cell> &cells)
{
for(auto cell : cells)
{
cell_map_[xlnt::cell::get_column_letter(cell.first + 1)] = cell.second;
}
}
xlnt::range rows() const
{
throw not_implemented();
}
xlnt::range columns() const
{
throw not_implemented();
}
void operator=(const worksheet_struct &other) = delete;
workbook &parent_;
std::string title_;
xlnt::cell freeze_panes_;
std::unordered_map<std::string, xlnt::cell> cell_map_;
std::vector<relationship> relationships_;
};
worksheet::worksheet(worksheet_struct *root) : root_(root)
{
}
std::string worksheet::to_string() const
{
return "<Worksheet \"" + root_->title_ + "\">";
}
workbook &worksheet::get_parent() const
{
return root_->parent_;
}
void worksheet::garbage_collect()
{
root_->garbage_collect();
}
std::set<cell> worksheet::get_cell_collection()
{
return root_->get_cell_collection();
}
std::string worksheet::get_title() const
{
return root_->title_;
}
void worksheet::set_title(const std::string &title)
{
root_->title_ = title;
}
cell worksheet::get_freeze_panes() const
{
return root_->freeze_panes_;
}
void worksheet::set_freeze_panes(xlnt::cell top_left_cell)
{
root_->set_freeze_panes(top_left_cell);
}
void worksheet::set_freeze_panes(const std::string &top_left_coordinate)
{
root_->set_freeze_panes(top_left_coordinate);
}
void worksheet::unfreeze_panes()
{
root_->unfreeze_panes();
}
xlnt::cell worksheet::cell(const std::string &coordinate)
{
return root_->cell(coordinate);
}
xlnt::cell worksheet::cell(int row, int column)
{
return root_->cell(row, column);
}
int worksheet::get_highest_row() const
{
return root_->get_highest_row();
}
int worksheet::get_highest_column() const
{
return root_->get_highest_column();
}
std::string worksheet::calculate_dimension() const
{
return root_->calculate_dimension();
}
range worksheet::range(const std::string &range_string, int row_offset, int column_offset)
{
return root_->range(range_string, row_offset, column_offset);
}
relationship worksheet::create_relationship(const std::string &relationship_type)
{
return root_->create_relationship(relationship_type);
}
//void worksheet::add_chart(chart chart);
void worksheet::merge_cells(const std::string &range_string)
{
root_->merge_cells(range_string);
}
void worksheet::merge_cells(int start_row, int start_column, int end_row, int end_column)
{
root_->merge_cells(start_row, start_column, end_row, end_column);
}
void worksheet::unmerge_cells(const std::string &range_string)
{
root_->unmerge_cells(range_string);
}
void worksheet::unmerge_cells(int start_row, int start_column, int end_row, int end_column)
{
root_->unmerge_cells(start_row, start_column, end_row, end_column);
}
void worksheet::append(const std::vector<xlnt::cell> &cells)
{
root_->append(cells);
}
void worksheet::append(const std::unordered_map<std::string, xlnt::cell> &cells)
{
root_->append(cells);
}
void worksheet::append(const std::unordered_map<int, xlnt::cell> &cells)
{
root_->append(cells);
}
xlnt::range worksheet::rows() const
{
return root_->rows();
}
xlnt::range worksheet::columns() const
{
return root_->columns();
}
bool worksheet::operator==(const worksheet &other) const
{
return root_ == other.root_;
}
bool worksheet::operator!=(const worksheet &other) const
{
return root_ != other.root_;
}
bool worksheet::operator==(std::nullptr_t) const
{
return root_ == nullptr;
}
bool worksheet::operator!=(std::nullptr_t) const
{
return root_ != nullptr;
}
void worksheet::operator=(const worksheet &other)
{
root_ = other.root_;
}
cell worksheet::operator[](const std::string &address)
{
return cell(address);
}
workbook::workbook() : active_worksheet_(nullptr)
{
auto ws = create_sheet();
ws.set_title("Sheet1");
active_worksheet_ = ws;
}
worksheet workbook::get_sheet_by_name(const std::string &name)
{
auto match = std::find_if(worksheets_.begin(), worksheets_.end(), [&](const worksheet &w) { return w.get_title() == name; });
if(match != worksheets_.end())
{
return worksheet(*match);
}
return worksheet(nullptr);
}
worksheet workbook::get_active()
{
return active_worksheet_;
}
worksheet workbook::create_sheet()
{
std::string title = "Sheet1";
int index = 1;
while(get_sheet_by_name(title) != nullptr)
{
title = "Sheet" + std::to_string(++index);
}
auto *worksheet = new worksheet_struct(*this, title);
worksheets_.push_back(worksheet);
return get_sheet_by_name(title);
}
worksheet workbook::create_sheet(std::size_t index)
{
auto ws = create_sheet();
if(index != worksheets_.size())
{
std::swap(worksheets_[index], worksheets_.back());
}
return ws;
}
std::vector<worksheet>::iterator workbook::begin()
{
return worksheets_.begin();
}
std::vector<worksheet>::iterator workbook::end()
{
return worksheets_.end();
}
std::vector<std::string> workbook::get_sheet_names() const
{
std::vector<std::string> names;
for(auto &ws : worksheets_)
{
names.push_back(ws.get_title());
}
return names;
}
worksheet workbook::operator[](const std::string &name)
{
return get_sheet_by_name(name);
}
void workbook::save(const std::string &filename)
{
auto package = package::open(filename);
package.close();
}
std::string cell_struct::to_string() const
{
return "<Cell " + parent_worksheet->title_ + "." + xlnt::cell::get_column_letter(column + 1) + std::to_string(row) + ">";
}
}