StarMirror/xlnt
1
0
Fork 0
mirror of https://github.com/tfussell/xlnt.git synced 2024-03-22 13:11:17 +08:00
Code Issues Projects Releases Wiki Activity

moved all impl classes to separate headers

Browse Source
This commit is contained in:
Thomas Fussell 2014-05-29 20:52:14 -04:00
parent 9ef1a5ef25
commit e92f1a624e
25 changed files with 789 additions and 1107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
include/xlnt/cell.h
View File

@ -1,5 +1,6 @@
#pragma once
#include <memory>
#include <string>
#include <unordered_map>
@ -10,7 +11,7 @@ namespace xlnt {
class cell_reference;
class worksheet;
struct cell_struct;
struct cell_impl;
typedef std::string comment;
@ -310,8 +311,7 @@ public:
static std::string check_error(const std::string &value);
cell();
cell(worksheet &ws, const std::string &column, row_t row);
cell(worksheet &ws, const std::string &column, row_t row, const std::string &initial_value);
cell(worksheet ws, const cell_reference &reference, const std::string &initial_value = std::string());
std::string get_value() const;
@ -350,8 +350,6 @@ public:
cell_reference get_reference() const;
cell get_offset(int row, int column);
bool is_date() const;
//std::pair<int, int> get_anchor() const;
@ -374,7 +372,7 @@ public:
bool operator==(const std::string &comparand) const;
bool operator==(const char *comparand) const;
bool operator==(const tm &comparand) const;
bool operator==(const cell &comparand) const { return root_ == comparand.root_; }
bool operator==(const cell &comparand) const { return d_ == comparand.d_; }
friend bool operator==(std::nullptr_t, const cell &cell);
friend bool operator==(bool comparand, const cell &cell);
@ -385,14 +383,9 @@ public:
friend bool operator==(const tm &comparand, const cell &cell);
private:
friend struct worksheet_struct;
static cell allocate(worksheet owner, column_t column_index, row_t row_index);
static void deallocate(cell cell);
cell(cell_struct *root);
cell_struct *root_;
friend class worksheet;
cell(cell_impl *d);
cell_impl *d_;
};
inline std::ostream &operator<<(std::ostream &stream, const xlnt::cell &cell)

6
include/xlnt/cell_reference.h
View File

@ -46,6 +46,7 @@ public:
static std::pair<std::string, row_t> split_reference(const std::string &reference_string,
bool &absolute_column, bool &absolute_row);
cell_reference();
cell_reference(const char *reference_string);
cell_reference(const std::string &reference_string);
cell_reference(const std::string &column, row_t row, bool absolute = false);
@ -74,7 +75,10 @@ public:
bool operator==(const cell_reference &comparand) const;
bool operator==(const std::string &reference_string) const { return *this == cell_reference(reference_string); }
bool operator==(const char *reference_string) const { return *this == std::string(reference_string); }
bool operator!=(const cell_reference &comparand) const { return !(*this == comparand); }
bool operator!=(const std::string &reference_string) const { return *this != cell_reference(reference_string); }
bool operator!=(const char *reference_string) const { return *this != std::string(reference_string); }
private:
column_t column_index_;
row_t row_index_;

49
include/xlnt/cell_struct.h
View File

@ -1,49 +0,0 @@
#pragma once
#include "cell.h"
#include "relationship.h"
namespace xlnt {
struct worksheet_struct;
struct cell_struct
{
cell_struct(worksheet_struct *ws, int column, int row)
: type(cell::type::null), parent_worksheet(ws),
column(column), row(row),
hyperlink_rel("invalid", "")
{
}
cell_struct()
: type(cell::type::null), parent_worksheet(nullptr),
column(0), row(0), hyperlink_rel("invalid", "")
{
}
std::string to_string() const;
cell::type type;
union
{
long double numeric_value;
bool bool_value;
};
std::string error_value;
tm date_value;
std::string string_value;
std::string formula_value;
worksheet_struct *parent_worksheet;
column_t column;
row_t row;
style *style_;
relationship hyperlink_rel;
bool merged;
};
} // namespace xlnt

31
include/xlnt/named_range.h
View File

@ -1,31 +0,0 @@
#pragma once
#include <string>
#include "range_reference.h"
#include "worksheet.h"
namespace xlnt {
class range_reference;
class worksheet;
struct named_range_struct;
class named_range
{
public:
named_range();
named_range(const std::string &name, worksheet ws, const range_reference &target);
range_reference get_target_range() const;
worksheet get_scope() const;
void set_scope(worksheet scope);
bool operator==(const named_range &comparand) const;
private:
std::string name_;
worksheet parent_worksheet_;
range_reference target_range_;
};
} // namespace xlnt

83
include/xlnt/workbook.h
View File

@ -5,16 +5,16 @@
#include <utility>
#include <vector>
#include "named_range.h"
namespace xlnt {
class drawing;
//class named_range;
class range;
class range_reference;
class relationship;
class worksheet;
struct workbook_impl;
enum class optimization
{
write,
@ -29,17 +29,16 @@ public:
workbook(optimization optimization = optimization::none);
~workbook();
//prevent copy and assignment
workbook &operator=(const workbook &) = delete;
workbook(const workbook &) = delete;
const workbook &operator=(const workbook &) = delete;
void read_workbook_settings(const std::string &xml_source);
//getters
worksheet get_active_sheet();
bool get_optimized_write() const { return optimized_write_; }
bool get_guess_types() const { return guess_types_; }
bool get_data_only() const { return data_only_; }
bool get_optimized_write() const;
bool get_guess_types() const;
bool get_data_only() const;
//create
worksheet create_sheet();
@ -57,32 +56,61 @@ public:
//container operations
worksheet get_sheet_by_name(const std::string &sheet_name);
const worksheet get_sheet_by_name(const std::string &sheet_name) const;
worksheet get_sheet_by_index(std::size_t index);
const worksheet get_sheet_by_index(std::size_t index) const;
bool contains(const std::string &key) const;
int get_index(worksheet worksheet);
worksheet operator[](const std::string &name);
worksheet operator[](int index);
std::vector<worksheet>::iterator begin();
std::vector<worksheet>::iterator end();
class iterator
{
public:
iterator(workbook &wb, std::size_t index);
worksheet operator*();
bool operator==(const iterator &comparand) const;
bool operator!=(const iterator &comparand) const { return !(*this == comparand); }
iterator operator++(int);
iterator &operator++();
private:
workbook &wb_;
std::size_t index_;
};
std::vector<worksheet>::const_iterator begin() const;
std::vector<worksheet>::const_iterator end() const;
iterator begin();
iterator end();
std::vector<worksheet>::const_iterator cbegin() const;
std::vector<worksheet>::const_iterator cend() const;
class const_iterator
{
public:
const_iterator(const workbook &wb, std::size_t index);
const worksheet operator*();
bool operator==(const const_iterator &comparand) const;
bool operator!=(const const_iterator &comparand) const { return !(*this == comparand); }
const_iterator operator++(int);
const_iterator &operator++();
private:
const workbook &wb_;
std::size_t index_;
};
const_iterator begin() const { return cbegin(); }
const_iterator end() const { return cend(); }
const_iterator cbegin() const;
const_iterator cend() const;
std::vector<std::string> get_sheet_names() const;
//named ranges
named_range create_named_range(const std::string &name, worksheet worksheet, const range_reference &reference);
std::vector<named_range> get_named_ranges();
void add_named_range(const std::string &name, named_range named_range);
bool has_named_range(const std::string &name, worksheet ws) const;
named_range get_named_range(const std::string &name, worksheet ws);
void remove_named_range(named_range named_range);
void create_named_range(const std::string &name, worksheet worksheet, const range_reference &reference);
bool has_named_range(const std::string &name) const;
range get_named_range(const std::string &name);
void remove_named_range(const std::string &name);
//serialization
void save(const std::string &filename);
@ -94,15 +122,8 @@ public:
std::unordered_map<std::string, std::pair<std::string, std::string>> get_relationships() const;
private:
bool optimized_write_;
bool optimized_read_;
bool guess_types_;
bool data_only_;
int active_sheet_index_;
std::vector<worksheet> worksheets_;
std::unordered_map<std::string, named_range> named_ranges_;
std::vector<relationship> relationships_;
std::vector<drawing> drawings_;
friend class worksheet;
workbook_impl *d_;
};
} // namespace xlnt

32
include/xlnt/worksheet.h
View File

@ -2,20 +2,22 @@
#include <list>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "types.h"
namespace xlnt {
class cell;
class cell_reference;
class named_range;
class range;
class range_reference;
class relationship;
class workbook;
struct worksheet_struct;
struct worksheet_impl;
struct page_setup
{
@ -117,8 +119,8 @@ class worksheet
{
public:
worksheet();
worksheet(workbook &parent);
worksheet(worksheet_struct *root);
worksheet(workbook &parent, const std::string &title = std::string());
worksheet(const worksheet &rhs);
std::string to_string() const;
workbook &get_parent() const;
@ -139,15 +141,22 @@ public:
cell get_cell(const cell_reference &reference);
const cell get_cell(const cell_reference &reference) const;
range get_range(const range_reference &reference);
range get_named_range(const std::string &name);
const range get_range(const range_reference &reference) const;
range rows() const;
range columns() const;
std::list<cell> get_cell_collection();
named_range create_named_range(const std::string &name, const range_reference &reference);
// named range
void create_named_range(const std::string &name, const range_reference &reference);
bool has_named_range(const std::string &name);
range get_named_range(const std::string &name);
void remove_named_range(const std::string &name);
// extents
int get_highest_row() const;
int get_highest_column() const;
row_t get_lowest_row() const;
row_t get_highest_row() const;
column_t get_lowest_column() const;
column_t get_highest_column() const;
range_reference calculate_dimension() const;
// relationships
@ -196,11 +205,8 @@ public:
private:
friend class workbook;
friend class cell;
static worksheet allocate(workbook &owner, const std::string &title);
static void deallocate(worksheet ws);
worksheet_struct *root_;
worksheet(worksheet_impl *d);
worksheet_impl *d_;
};
} // namespace xlnt

7
include/xlnt/xlnt.h
View File

@ -6,16 +6,10 @@
#include <unordered_map>
#include <vector>
#include "zip.h"
#include "unzip.h"
#include "cell.h"
#include "cell_reference.h"
#include "constants.h"
#include "custom_exceptions.h"
#include "drawing.h"
#include "named_range.h"
#include "protection.h"
#include "range.h"
#include "reader.h"
#include "range_reference.h"
@ -24,4 +18,3 @@
#include "workbook.h"
#include "worksheet.h"
#include "writer.h"
#include "zip_file.h"

210
source/cell.cpp
View File

@ -3,15 +3,23 @@
#include <sstream>
#include "cell.h"
#include "cell_impl.h"
#include "cell_reference.h"
#include "cell_struct.h"
#include "relationship.h"
#include "worksheet.h"
namespace xlnt {
struct worksheet_struct;
cell_impl::cell_impl() : hyperlink_rel("hyperlink"), column(0), row(0), type_(type::null)
{
}
cell_impl::cell_impl(int column_index, int row_index) : hyperlink_rel("hyperlink"), column(column_index), row(row_index), type_(type::null)
{
}
const xlnt::color xlnt::color::black(0);
const xlnt::color xlnt::color::white(1);
@ -26,46 +34,44 @@ const std::unordered_map<std::string, int> cell::ErrorCodes =
{"#N/A!", 6}
};
cell::cell() : root_(nullptr)
cell::cell() : d_(nullptr)
{
}
cell::cell(worksheet &worksheet, const std::string &column, row_t row) : root_(nullptr)
cell::cell(cell_impl *d) : d_(d)
{
cell self = worksheet.get_cell(column + std::to_string(row));
root_ = self.root_;
}
cell::cell(worksheet &worksheet, const std::string &column, row_t row, const std::string &initial_value) : root_(nullptr)
cell::cell(worksheet worksheet, const cell_reference &reference, const std::string &initial_value) : d_(nullptr)
{
cell self = worksheet.get_cell(column + std::to_string(row));
root_ = self.root_;
*this = initial_value;
}
cell self = worksheet.get_cell(reference);
d_ = self.d_;
cell::cell(cell_struct *root) : root_(root)
{
if(initial_value != "")
{
*this = initial_value;
}
}
std::string cell::get_value() const
{
switch(root_->type)
switch(d_->type_)
{
case type::string:
return root_->string_value;
case type::numeric:
return std::to_string(root_->numeric_value);
case type::formula:
return root_->formula_value;
case type::error:
return root_->error_value;
case type::null:
case cell_impl::type::string:
return d_->string_value;
case cell_impl::type::numeric:
return std::to_string(d_->numeric_value);
case cell_impl::type::formula:
return d_->formula_value;
case cell_impl::type::error:
return d_->error_value;
case cell_impl::type::null:
return "";
case type::date:
case cell_impl::type::date:
return "00:00:00";
case type::boolean:
return root_->bool_value ? "TRUE" : "FALSE";
case cell_impl::type::boolean:
return d_->numeric_value != 0 ? "TRUE" : "FALSE";
default:
throw std::runtime_error("bad enum");
}
@ -73,12 +79,12 @@ std::string cell::get_value() const
row_t cell::get_row() const
{
return root_->row + 1;
return d_->row + 1;
}
std::string cell::get_column() const
{
return cell_reference::column_string_from_index(root_->column + 1);
return cell_reference::column_string_from_index(d_->column + 1);
}
std::vector<std::string> split_string(const std::string &string, char delim = ' ')
@ -166,60 +172,60 @@ cell::type cell::data_type_for_value(const std::string &value)
void cell::set_explicit_value(const std::string &value, type data_type)
{
root_->type = data_type;
d_->type_ = (cell_impl::type)data_type;
switch(data_type)
{
case type::formula: root_->formula_value = value; return;
case type::date: root_->date_value.tm_hour = std::stoi(value); return;
case type::error: root_->error_value = value; return;
case type::boolean: root_->bool_value = value == "true"; return;
case type::formula: d_->formula_value = value; return;
case type::date: d_->date_value.tm_hour = std::stoi(value); return;
case type::error: d_->error_value = value; return;
case type::boolean: d_->numeric_value = value == "true"; return;
case type::null: return;
case type::numeric: root_->numeric_value = std::stod(value); return;
case type::string: root_->string_value = value; return;
case type::numeric: d_->numeric_value = std::stod(value); return;
case type::string: d_->string_value = value; return;
default: throw std::runtime_error("bad enum");
}
}
void cell::set_hyperlink(const std::string &url)
{
root_->type = type::hyperlink;
root_->hyperlink_rel = worksheet(root_->parent_worksheet).create_relationship("hyperlink", url);
d_->type_ = cell_impl::type::hyperlink;
d_->string_value = url;
}
void cell::set_merged(bool merged)
{
root_->merged = merged;
d_->merged = merged;
}
bool cell::is_merged() const
{
return root_->merged;
return d_->merged;
}
bool cell::bind_value()
{
root_->type = type::null;
d_->type_ = cell_impl::type::null;
return true;
}
bool cell::bind_value(int value)
{
root_->type = type::numeric;
root_->numeric_value = value;
d_->type_ = cell_impl::type::numeric;
d_->numeric_value = value;
return true;
}
bool cell::bind_value(double value)
{
root_->type = type::numeric;
root_->numeric_value = value;
d_->type_ = cell_impl::type::numeric;
d_->numeric_value = value;
return true;
}
bool cell::bind_value(const std::string &value)
{
//Given a value, infer type and display options.
root_->type = data_type_for_value(value);
d_->type_ = (cell_impl::type)data_type_for_value(value);
return true;
}
@ -230,57 +236,57 @@ bool cell::bind_value(const char *value)
bool cell::bind_value(bool value)
{
root_->type = type::boolean;
root_->bool_value = value;
d_->type_ = cell_impl::type::boolean;
d_->numeric_value = value ? 1 : 0;
return true;
}
bool cell::bind_value(const tm &value)
{
root_->type = type::date;
root_->date_value = value;
d_->type_ = cell_impl::type::date;
d_->date_value = value;
return true;
}
bool cell::is_date() const
{
return root_->type == type::date;
return d_->type_ == cell_impl::type::date;
}
cell_reference cell::get_reference() const
{
return {root_->column, root_->row};
return {d_->column, d_->row};
}
std::string cell::get_hyperlink_rel_id() const
{
return root_->hyperlink_rel.get_id();
return d_->hyperlink_rel.get_id();
}
bool cell::operator==(std::nullptr_t) const
{
return root_ == nullptr;
return d_ == nullptr;
}
bool cell::operator==(int comparand) const
{
return root_->type == type::numeric && root_->numeric_value == comparand;
return d_->type_ == cell_impl::type::numeric && d_->numeric_value == comparand;
}
bool cell::operator==(double comparand) const
{
return root_->type == type::numeric && root_->numeric_value == comparand;
return d_->type_ == cell_impl::type::numeric && d_->numeric_value == comparand;
}
bool cell::operator==(const std::string &comparand) const
{
if(root_->type == type::hyperlink)
if(d_->type_ == cell_impl::type::hyperlink)
{
return root_->hyperlink_rel.get_target_uri() == comparand;
return d_->hyperlink_rel.get_target_uri() == comparand;
}
if(root_->type == type::string)
if(d_->type_ == cell_impl::type::string)
{
return root_->string_value == comparand;
return d_->string_value == comparand;
}
return false;
}
@ -292,7 +298,7 @@ bool cell::operator==(const char *comparand) const
bool cell::operator==(const tm &comparand) const
{
return root_->type == cell::type::date && root_->date_value.tm_hour == comparand.tm_hour;
return d_->type_ == cell_impl::type::date && d_->date_value.tm_hour == comparand.tm_hour;
}
bool operator==(int comparand, const xlnt::cell &cell)
@ -317,94 +323,87 @@ bool operator==(const tm &comparand, const xlnt::cell &cell)
style &cell::get_style()
{
if(root_->style_ == nullptr)
if(d_->style_ == nullptr)
{
root_->style_ = new style();
d_->style_ = new style();
}
return *root_->style_;
return *d_->style_;
}
const style &cell::get_style() const
{
if(root_->style_ == nullptr)
if(d_->style_ == nullptr)
{
root_->style_ = new style();
d_->style_ = new style();
}
return *root_->style_;
return *d_->style_;
}
xlnt::cell::type cell::get_data_type() const
{
return root_->type;
}
xlnt::cell cell::get_offset(int row_offset, int column_offset)
{
worksheet parent_wrapper(root_->parent_worksheet);
cell_reference ref(root_->column + column_offset, root_->row + row_offset);
return parent_wrapper[ref];
return (type)d_->type_;
}
cell &cell::operator=(const cell &rhs)
{
root_ = rhs.root_;
d_ = rhs.d_;
return *this;
}
cell &cell::operator=(int value)
{
root_->type = type::numeric;
root_->numeric_value = value;
d_->type_ = cell_impl::type::numeric;
d_->numeric_value = value;
return *this;
}
cell &cell::operator=(double value)
{
root_->type = type::numeric;
root_->numeric_value = value;
d_->type_ = cell_impl::type::numeric;
d_->numeric_value = value;
return *this;
}
cell &cell::operator=(bool value)
{
root_->type = type::boolean;
root_->bool_value = value;
d_->type_ = cell_impl::type::boolean;
d_->numeric_value = value ? 1 : 0;
return *this;
}
cell &cell::operator=(const std::string &value)
{
root_->type = data_type_for_value(value);
d_->type_ = (cell_impl::type)data_type_for_value(value);
switch(root_->type)
switch((type)d_->type_)
{
case type::date:
{
root_->date_value = std::tm();
d_->date_value = std::tm();
auto split = split_string(value, ':');
root_->date_value.tm_hour = std::stoi(split[0]);
root_->date_value.tm_min = std::stoi(split[1]);
d_->date_value.tm_hour = std::stoi(split[0]);
d_->date_value.tm_min = std::stoi(split[1]);
if(split.size() > 2)
{
root_->date_value.tm_sec = std::stoi(split[2]);
d_->date_value.tm_sec = std::stoi(split[2]);
}
break;
}
case type::formula:
root_->formula_value = value;
d_->formula_value = value;
break;
case type::numeric:
root_->numeric_value = std::stod(value);
d_->numeric_value = std::stod(value);
break;
case type::boolean:
root_->bool_value = value == "TRUE" || value == "true";
d_->numeric_value = value == "TRUE" || value == "true";
break;
case type::error:
root_->error_value = value;
d_->error_value = value;
break;
case type::string:
root_->string_value = value;
d_->string_value = value;
break;
case type::null:
break;
@ -422,29 +421,14 @@ cell &cell::operator=(const char *value)
cell &cell::operator=(const tm &value)
{
root_->type = type::date;
root_->date_value = value;
d_->type_ = cell_impl::type::date;
d_->date_value = value;
return *this;
}
std::string cell::to_string() const
{
return root_->to_string();
}
std::string cell_struct::to_string() const
{
return "<Cell " + worksheet(parent_worksheet).get_title() + "." + cell_reference(column, row).to_string() + ">";
}
cell cell::allocate(xlnt::worksheet owner, column_t column_index, row_t row_index)
{
return new cell_struct(owner.root_, column_index, row_index);
}
void cell::deallocate(xlnt::cell cell)
{
delete cell.root_;
return "<Cell " + cell_reference(d_->column, d_->row).to_string() + ">";
}
} // namespace xlnt

42
source/cell_impl.h Normal file
View File

@ -0,0 +1,42 @@
#pragma once
#include "types.h"
#include "relationship.h"
namespace xlnt {
class style;
struct cell_impl
{
cell_impl();
cell_impl(int column_index, int row_index);
std::string to_string() const;
enum class type
{
null,
numeric,
string,
date,
formula,
boolean,
error,
hyperlink
};
type type_;
long double numeric_value;
std::string error_value;
tm date_value;
std::string string_value;
std::string formula_value;
column_t column;
row_t row;
style *style_;
relationship hyperlink_rel;
bool merged;
};
}

4
source/cell_reference.cpp
View File

@ -18,6 +18,10 @@ cell_reference cell_reference::make_absolute(const cell_reference &relative_refe
copy.absolute_ = true;
return copy;
}
cell_reference::cell_reference() : cell_reference(0, 0, false)
{
}
cell_reference::cell_reference(const std::string &string)
{

0
include/xlnt/constants.h → source/constants.h
View File

40
source/named_range.cpp
View File

@ -1,40 +0,0 @@
#include "named_range.h"
#include "range_reference.h"
#include "worksheet.h"
namespace xlnt {
void named_range::set_scope(worksheet scope)
{
parent_worksheet_ = scope;
}
bool named_range::operator==(const xlnt::named_range &comparand) const
{
return comparand.parent_worksheet_ == parent_worksheet_
&& comparand.target_range_ == target_range_;
}
named_range::named_range()
{
}
named_range::named_range(const std::string &name, worksheet ws, const range_reference &target)
: name_(name),
parent_worksheet_(ws),
target_range_(target)
{
}
range_reference named_range::get_target_range() const
{
return target_range_;
}
worksheet named_range::get_scope() const
{
return parent_worksheet_;
}
} // namespace xlnt

0
include/xlnt/protection.h → source/protection.h
View File

1
source/reader.cpp
View File

@ -3,7 +3,6 @@
#include "reader.h"
#include "cell.h"
#include "named_range.h"
#include "range_reference.h"
#include "workbook.h"
#include "worksheet.h"

331
source/workbook.cpp
View File

@ -3,23 +3,28 @@
#include <pugixml.hpp>
#include "workbook.h"
#include "cell_impl.h"
#include "custom_exceptions.h"
#include "drawing.h"
#include "named_range.h"
#include "range.h"
#include "reader.h"
#include "relationship.h"
#include "workbook_impl.h"
#include "worksheet.h"
#include "worksheet_impl.h"
#include "writer.h"
#include "zip_file.h"
namespace xlnt {
workbook::workbook(optimization optimize)
: optimized_write_(optimize==optimization::write),
optimized_read_(optimize==optimization::read),
active_sheet_index_(0)
workbook_impl::workbook_impl(optimization o) : optimized_read_(o == optimization::read), optimized_write_(o == optimization::write), active_sheet_index_(0)
{
if(!optimized_write_)
}
workbook::workbook(optimization optimize) : d_(new workbook_impl(optimize))
{
if(!d_->optimized_read_)
{
create_sheet("Sheet1");
}
@ -30,26 +35,95 @@ workbook::~workbook()
clear();
}
workbook::iterator::iterator(workbook &wb, std::size_t index) : wb_(wb), index_(index)
{
}
worksheet workbook::iterator::operator*()
{
return wb_[index_];
}
workbook::iterator &workbook::iterator::operator++()
{
index_++;
return *this;
}
workbook::iterator workbook::iterator::operator++(int)
{
iterator old(wb_, index_);
++*this;
return old;
}
bool workbook::iterator::operator==(const iterator &comparand) const
{
return index_ == comparand.index_ && wb_ == comparand.wb_;
}
workbook::const_iterator::const_iterator(const workbook &wb, std::size_t index) : wb_(wb), index_(index)
{
}
const worksheet workbook::const_iterator::operator*()
{
return wb_.get_sheet_by_index(index_);
}
workbook::const_iterator &workbook::const_iterator::operator++()
{
index_++;
return *this;
}
workbook::const_iterator workbook::const_iterator::operator++(int)
{
const_iterator old(wb_, index_);
++*this;
return old;
}
bool workbook::const_iterator::operator==(const const_iterator &comparand) const
{
return index_ == comparand.index_ && wb_ == comparand.wb_;
}
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())
auto title_equals = [&](worksheet_impl &ws) { return worksheet(&ws).get_title() == name; };
auto match = std::find_if(d_->worksheets_.begin(), d_->worksheets_.end(), title_equals);
if(match != d_->worksheets_.end())
{
return worksheet(*match);
return worksheet(&*match);
}
return worksheet(nullptr);
return worksheet();
}
worksheet workbook::get_sheet_by_index(std::size_t index)
{
return worksheet(&d_->worksheets_[index]);
}
const worksheet workbook::get_sheet_by_index(std::size_t index) const
{
return worksheet(&d_->worksheets_.at(index));
}
worksheet workbook::get_active_sheet()
{
return worksheets_[active_sheet_index_];
return worksheet(&d_->worksheets_[d_->active_sheet_index_]);
}
bool workbook::has_named_range(const std::string &name, xlnt::worksheet ws) const
bool workbook::has_named_range(const std::string &name) const
{
for(auto named_range : named_ranges_)
for(auto worksheet : *this)
{
if(named_range.first == name && named_range.second.get_scope() == ws)
if(worksheet.has_named_range(name))
{
return true;
}
@ -59,27 +133,26 @@ bool workbook::has_named_range(const std::string &name, xlnt::worksheet ws) cons
worksheet workbook::create_sheet()
{
if(optimized_read_)
if(d_->optimized_read_)
{
throw std::runtime_error("this is a read-only workbook");
}
std::string title = "Sheet1";
int index = 1;
while(get_sheet_by_name(title) != nullptr)
{
title = "Sheet" + std::to_string(++index);
}
worksheet ws = worksheet(worksheet::allocate(*this, title));
worksheets_.push_back(ws);
return get_sheet_by_name(title);
d_->worksheets_.emplace_back(this, title);
return worksheet(&d_->worksheets_.back());
}
void workbook::add_sheet(xlnt::worksheet worksheet)
{
if(optimized_read_)
if(d_->optimized_read_)
{
throw std::runtime_error("this is a read-only workbook");
}
@ -91,25 +164,14 @@ void workbook::add_sheet(xlnt::worksheet worksheet)
throw std::runtime_error("worksheet already in workbook");
}
}
worksheets_.push_back(worksheet);
d_->worksheets_.emplace_back(*worksheet.d_);
}
void workbook::add_sheet(xlnt::worksheet worksheet, std::size_t index)
{
if(optimized_read_)
{
throw std::runtime_error("this is a read-only workbook");
}
for(auto ws : *this)
{
if(worksheet == ws)
{
throw std::runtime_error("worksheet already in workbook");
}
}
worksheets_.push_back(worksheet);
std::swap(worksheets_[index], worksheets_.back());
add_sheet(worksheet);
// std::swap(d_->worksheets_[index], d_->worksheets_.back());
}
int workbook::get_index(xlnt::worksheet worksheet)
@ -126,71 +188,42 @@ int workbook::get_index(xlnt::worksheet worksheet)
throw std::runtime_error("worksheet isn't owned by this workbook");
}
named_range workbook::create_named_range(const std::string &name, worksheet range_owner, const range_reference &reference)
void workbook::create_named_range(const std::string &name, worksheet range_owner, const range_reference &reference)
{
for(auto ws : worksheets_)
auto match = get_sheet_by_name(range_owner.get_title());
if(match != nullptr)
{
if(ws == range_owner)
{
named_ranges_[name] = range_owner.create_named_range(name, reference);
return named_ranges_[name];
}
match.create_named_range(name, reference);
return;
}
throw std::runtime_error("worksheet isn't owned by this workbook");
}
void workbook::add_named_range(const std::string &name, named_range named_range)
void workbook::remove_named_range(const std::string &name)
{
for(auto ws : worksheets_)
for(auto ws : *this)
{
if(ws == named_range.get_scope())
if(ws.has_named_range(name))
{
named_ranges_[name] = named_range;
ws.remove_named_range(name);
return;
}
}
throw std::runtime_error("worksheet isn't owned by this workbook");
throw std::runtime_error("named range not found");
}
std::vector<named_range> workbook::get_named_ranges()
range workbook::get_named_range(const std::string &name)
{
std::vector<named_range> named_ranges;
for(auto named_range : named_ranges_)
for(auto ws : *this)
{
named_ranges.push_back(named_range.second);
}
return named_ranges;
}
void workbook::remove_named_range(named_range named_range)
{
std::string key_match = "";
for(auto r : named_ranges_)
{
if(r.second == named_range)
if(ws.has_named_range(name))
{
key_match = r.first;
return ws.get_named_range(name);
}
}
if(key_match == "")
{
throw std::runtime_error("range not found in worksheet");
}
named_ranges_.erase(key_match);
}
named_range workbook::get_named_range(const std::string &name, worksheet ws)
{
for(auto named_range : named_ranges_)
{
if(named_range.first == name && named_range.second.get_scope() == ws)
{
return named_range.second;
}
}
throw std::runtime_error("doesn't exist");
throw std::runtime_error("named range not found");
}
void workbook::load(const std::string &filename)
@ -216,10 +249,7 @@ void workbook::load(const std::string &filename)
auto root_node = doc.child("workbook");
auto sheets_node = root_node.child("sheets");
while(!worksheets_.empty())
{
remove_sheet(worksheets_.front());
}
clear();
std::vector<std::string> shared_strings;
if(f.has_file("xl/sharedStrings.xml"))
@ -239,29 +269,34 @@ void workbook::load(const std::string &filename)
void workbook::remove_sheet(worksheet ws)
{
auto match_iter = std::find(worksheets_.begin(), worksheets_.end(), ws);
if(match_iter == worksheets_.end())
auto match_iter = std::find_if(d_->worksheets_.begin(), d_->worksheets_.end(), [=](worksheet_impl &comp) { return worksheet(&comp) == ws; });
if(match_iter == d_->worksheets_.end())
{
throw std::runtime_error("worksheet not owned by this workbook");
}
worksheet::deallocate(*match_iter);
worksheets_.erase(match_iter);
d_->worksheets_.erase(match_iter);
}
worksheet workbook::create_sheet(std::size_t index)
{
auto ws = create_sheet();
if(index != worksheets_.size())
create_sheet();
if(index != d_->worksheets_.size())
{
std::swap(worksheets_[index], worksheets_.back());
std::swap(d_->worksheets_[index], d_->worksheets_.back());
}
return ws;
return worksheet(&d_->worksheets_[index]);
}
worksheet workbook::create_sheet(std::size_t index, const std::string &title)
{
auto ws = create_sheet(index);
ws.set_title(title);
return ws;
}
@ -278,60 +313,62 @@ worksheet workbook::create_sheet(const std::string &title)
throw bad_sheet_title(title);
}
if(get_sheet_by_name(title) != nullptr)
if(std::find_if(d_->worksheets_.begin(), d_->worksheets_.end(), [&](worksheet_impl &ws) { return worksheet(&ws).get_title() == title; }) != d_->worksheets_.end())
{
throw std::runtime_error("sheet exists");
}
auto ws = worksheet::allocate(*this, title);
worksheets_.push_back(ws);
return worksheet(ws);
auto ws = create_sheet();
ws.set_title(title);
return ws;
}
std::vector<worksheet>::iterator workbook::begin()
workbook::iterator workbook::begin()
{
return worksheets_.begin();
return iterator(*this, 0);
}
std::vector<worksheet>::iterator workbook::end()
workbook::iterator workbook::end()
{
return worksheets_.end();
return iterator(*this, d_->worksheets_.size());
}
workbook::const_iterator workbook::cbegin() const
{
return const_iterator(*this, 0);
}
workbook::const_iterator workbook::cend() const
{
return const_iterator(*this, d_->worksheets_.size());
}
std::vector<std::string> workbook::get_sheet_names() const
{
std::vector<std::string> names;
for(auto &ws : worksheets_)
for(auto ws : *this)
{
names.push_back(ws.get_title());
}
return names;
}
worksheet workbook::operator[](const std::string &name)
{
for(auto sheet : worksheets_)
{
if(sheet.get_title() == name)
{
return sheet;
}
}
throw std::runtime_error("sheet not found");
return get_sheet_by_name(name);
}
worksheet workbook::operator[](int index)
{
return worksheets_[index];
return worksheet(&d_->worksheets_[index]);
}
void workbook::clear()
{
while(!worksheets_.empty())
{
worksheet::deallocate(worksheets_.back());
worksheets_.pop_back();
}
d_->worksheets_.clear();
}
void workbook::save(const std::string &filename)
@ -398,69 +435,7 @@ void workbook::save(const std::string &filename)
bool workbook::operator==(const workbook &rhs) const
{
if(optimized_write_ == rhs.optimized_write_
&& optimized_read_ == rhs.optimized_read_
&& guess_types_ == rhs.guess_types_
&& data_only_ == rhs.data_only_
&& active_sheet_index_ == rhs.active_sheet_index_)
{
if(worksheets_.size() != rhs.worksheets_.size())
{
return false;
}
for(std::size_t i = 0; i < worksheets_.size(); i++)
{
if(worksheets_[i] != rhs.worksheets_[i])
{
return false;
}
}
/*
if(named_ranges_.size() != rhs.named_ranges_.size())
{
return false;
}
for(int i = 0; i < named_ranges_.size(); i++)
{
if(named_ranges_[i] != rhs.named_ranges_[i])
{
return false;
}
}
if(relationships_.size() != rhs.relationships_.size())
{
return false;
}
for(int i = 0; i < relationships_.size(); i++)
{
if(relationships_[i] != rhs.relationships_[i])
{
return false;
}
}
if(drawings_.size() != rhs.drawings_.size())
{
return false;
}
for(int i = 0; i < drawings_.size(); i++)
{
if(drawings_[i] != rhs.drawings_[i])
{
return false;
}
}
*/
return true;
}
return false;
return d_ == rhs.d_;
}
}

16
source/workbook_impl.h Normal file
View File

@ -0,0 +1,16 @@
namespace xlnt {
struct workbook_impl
{
workbook_impl(optimization o);
bool optimized_write_;
bool optimized_read_;
bool guess_types_;
bool data_only_;
int active_sheet_index_;
std::vector<worksheet_impl> worksheets_;
std::vector<relationship> relationships_;
std::vector<drawing> drawings_;
};
} // namespace xlnt

561
source/worksheet.cpp
View File

@ -2,305 +2,41 @@
#include "worksheet.h"
#include "cell.h"
#include "cell_struct.h"
#include "named_range.h"
#include "range.h"
#include "range_reference.h"
#include "relationship.h"
#include "workbook.h"
#include "worksheet_impl.h"
namespace xlnt {
struct worksheet_struct
worksheet::worksheet() : d_(nullptr)
{
worksheet_struct(workbook &parent_workbook, const std::string &title)
: parent_(parent_workbook), title_(title), freeze_panes_("A1")
{
}
~worksheet_struct()
{
clear();
}
}
void clear()
{
cell_map_.clear();
}
void garbage_collect()
{
std::vector<cell_reference> null_cell_keys;
for(auto &key_cell_pair : cell_map_)
{
if(cell(&key_cell_pair.second).get_data_type() == cell::type::null)
{
null_cell_keys.push_back(key_cell_pair.first);
}
}
while(!null_cell_keys.empty())
{
cell_map_.erase(null_cell_keys.back());
null_cell_keys.pop_back();
}
}
std::list<cell> get_cell_collection()
{
std::list<cell> cells;
for(auto &c : cell_map_)
{
cells.push_front(cell(&c.second));
}
return cells;
}
std::string get_title() const
{
return title_;
}
void set_title(const std::string &title)
{
title_ = title;
}
cell_reference get_freeze_panes() const
{
return freeze_panes_;
}
void set_freeze_panes(const cell_reference &ref)
{
freeze_panes_ = ref;
}
void unfreeze_panes()
{
freeze_panes_ = "A1";
}
cell get_cell(const cell_reference &reference)
{
if(cell_map_.find(reference) == cell_map_.end())
{
cell_map_[reference] = cell_struct(this, reference.get_column_index(), reference.get_row_index());
}
return &cell_map_[reference];
}
/*
const xlnt::cell get_cell(const cell_reference &reference) const
{
if(cell_map_.find(reference) == cell_map_.end())
{
throw std::runtime_error("cell not found");
}
return &cell_map_.at(reference);
}
*/
int get_highest_row() const
{
row_t highest = 0;
for(auto &cell : cell_map_)
{
highest = std::max(highest, cell.first.get_row_index());
}
return highest + 1;
}
int get_highest_column() const
{
column_t highest = 0;
for(auto &cell : cell_map_)
{
highest = std::max(highest, cell.first.get_column_index());
}
return highest + 1;
}
int get_lowest_row() const
{
if(cell_map_.empty())
{
return 1;
}
row_t lowest = cell_map_.begin()->first.get_row_index();
for(auto &cell : cell_map_)
{
lowest = std::min(lowest, cell.first.get_row_index());
}
return lowest + 1;
}
int get_lowest_column() const
{
if(cell_map_.empty())
{
return 1;
}
column_t lowest = cell_map_.begin()->first.get_column_index();
for(auto &cell : cell_map_)
{
lowest = std::min(lowest, cell.first.get_column_index());
}
return lowest + 1;
}
range_reference calculate_dimension() const
{
int lowest_column = get_lowest_column();
int lowest_row = get_lowest_row();
int highest_column = get_highest_column();
int highest_row = get_highest_row();
return range_reference(lowest_column - 1, lowest_row - 1, highest_column - 1, highest_row - 1);
}
range get_range(const range_reference &reference)
{
return range(worksheet(this), reference);
}
relationship create_relationship(const std::string &relationship_type, const std::string &target_uri)
{
std::string r_id = "rId" + std::to_string(relationships_.size() + 1);
relationships_.push_back(relationship(relationship_type, r_id, target_uri));
return relationships_.back();
}
//void add_chart(chart chart);
void merge_cells(const range_reference &reference)
{
merged_cells_.push_back(reference);
bool first = true;
for(auto row : get_range(reference))
{
for(auto cell : row)
{
cell.set_merged(true);
if(!first)
{
cell.bind_value();
}
first = false;
}
}
}
void unmerge_cells(const range_reference &reference)
{
auto match = std::find(merged_cells_.begin(), merged_cells_.end(), reference);
if(match == merged_cells_.end())
{
throw std::runtime_error("cells not merged");
}
merged_cells_.erase(match);
for(auto row : get_range(reference))
{
for(auto cell : row)
{
cell.set_merged(false);
}
}
}
void append(const std::vector<std::string> &cells)
{
int row = get_highest_row();
if(cell_map_.size() == 0)
{
row--;
}
int column = 0;
for(auto cell : cells)
{
this->get_cell(cell_reference(column++, row)) = cell;
}
}
void append(const std::unordered_map<std::string, std::string> &cells)
{
int row = get_highest_row() - 1;
if(cell_map_.size() != 0)
{
row++;
}
for(auto cell : cells)
{
this->get_cell(cell_reference(cell.first, row + 1)) = cell.second;
}
}
void append(const std::unordered_map<int, std::string> &cells)
{
int row = get_highest_row() - 1;
if(cell_map_.size() != 0)
{
row++;
}
for(auto cell : cells)
{
this->get_cell(cell_reference(cell.first, row)) = cell.second;
}
}
range rows()
{
return get_range(calculate_dimension());
}
void operator=(const worksheet_struct &other) = delete;
workbook &parent_;
std::string title_;
cell_reference freeze_panes_;
std::unordered_map<cell_reference, cell_struct, cell_reference_hash> cell_map_;
std::vector<relationship> relationships_;
page_setup page_setup_;
range_reference auto_filter_;
margins page_margins_;
std::vector<range_reference> merged_cells_;
std::unordered_map<std::string, named_range> named_ranges_;
};
worksheet::worksheet() : root_(nullptr)
worksheet::worksheet(worksheet_impl *d) : d_(d)
{
}
worksheet::worksheet(worksheet_struct *root) : root_(root)
worksheet::worksheet(const worksheet &rhs) : d_(rhs.d_)
{
}
worksheet::worksheet(workbook &parent)
worksheet::worksheet(workbook &parent, const std::string &title) : d_(title == "" ? parent.create_sheet().d_ : parent.create_sheet(title).d_)
{
*this = parent.create_sheet();
}
bool worksheet::has_frozen_panes() const
{
return !(get_frozen_panes() == cell_reference("A1"));
return get_frozen_panes() != cell_reference("A1");
}
named_range worksheet::create_named_range(const std::string &name, const range_reference &reference)
void worksheet::create_named_range(const std::string &name, const range_reference &reference)
{
root_->named_ranges_[name] = named_range(name, *this, reference);
return root_->named_ranges_[name];
d_->named_ranges_[name] = reference;
}
cell worksheet::operator[](const cell_reference &ref)
@ -310,17 +46,17 @@ cell worksheet::operator[](const cell_reference &ref)
std::vector<range_reference> worksheet::get_merged_ranges() const
{
return root_->merged_cells_;
return d_->merged_cells_;
}
margins &worksheet::get_page_margins()
{
return root_->page_margins_;
return d_->page_margins_;
}
void worksheet::set_auto_filter(const range_reference &reference)
{
root_->auto_filter_ = reference;
d_->auto_filter_ = reference;
}
void worksheet::set_auto_filter(const xlnt::range &range)
@ -330,179 +66,349 @@ void worksheet::set_auto_filter(const xlnt::range &range)
range_reference worksheet::get_auto_filter() const
{
return root_->auto_filter_;
return d_->auto_filter_;
}
bool worksheet::has_auto_filter() const
{
return root_->auto_filter_.get_width() > 0;
return d_->auto_filter_.get_width() > 0;
}
void worksheet::unset_auto_filter()
{
root_->auto_filter_ = range_reference(0, 0, 0, 0);
d_->auto_filter_ = range_reference(0, 0, 0, 0);
}
page_setup &worksheet::get_page_setup()
{
return root_->page_setup_;
return d_->page_setup_;
}
std::string worksheet::to_string() const
{
return "<Worksheet \"" + root_->title_ + "\">";
return "<Worksheet \"" + d_->title_ + "\">";
}
workbook &worksheet::get_parent() const
{
return root_->parent_;
return *d_->parent_;
}
void worksheet::garbage_collect()
{
root_->garbage_collect();
auto cell_map_iter = d_->cell_map_.begin();
while(cell_map_iter != d_->cell_map_.end())
{
auto cell_iter = cell_map_iter->second.begin();
while(cell_iter != cell_map_iter->second.end())
{
if(cell(&cell_iter->second).get_data_type() == cell::type::null)
{
cell_iter = cell_map_iter->second.erase(cell_iter);
continue;
}
cell_iter++;
}
if(cell_map_iter->second.empty())
{
cell_map_iter = d_->cell_map_.erase(cell_map_iter);
continue;
}
cell_map_iter++;
}
}
std::list<cell> worksheet::get_cell_collection()
{
return root_->get_cell_collection();
std::list<cell> cells;
for(auto &c : d_->cell_map_)
{
for(auto &d : c.second)
{
cells.push_back(cell(&d.second));
}
}
return cells;
}
std::string worksheet::get_title() const
{
if(root_ == nullptr)
if(d_ == nullptr)
{
throw std::runtime_error("null worksheet");
}
return root_->title_;
return d_->title_;
}
void worksheet::set_title(const std::string &title)
{
root_->title_ = title;
d_->title_ = title;
}
cell_reference worksheet::get_frozen_panes() const
{
return root_->freeze_panes_;
return d_->freeze_panes_;
}
void worksheet::freeze_panes(xlnt::cell top_left_cell)
{
root_->set_freeze_panes(top_left_cell.get_reference());
d_->freeze_panes_ = top_left_cell.get_reference();
}
void worksheet::freeze_panes(const std::string &top_left_coordinate)
{
root_->set_freeze_panes(top_left_coordinate);
d_->freeze_panes_ = cell_reference(top_left_coordinate);
}
void worksheet::unfreeze_panes()
{
root_->unfreeze_panes();
d_->freeze_panes_ = cell_reference("A1");
}
cell worksheet::get_cell(const cell_reference &reference)
{
return root_->get_cell(reference);
if(d_->cell_map_.find(reference.get_row_index()) == d_->cell_map_.end())
{
d_->cell_map_[reference.get_row_index()] = std::unordered_map<int, cell_impl>();
}
auto &row = d_->cell_map_[reference.get_row_index()];
if(row.find(reference.get_column_index()) == row.end())
{
row[reference.get_column_index()] = cell_impl(reference.get_column_index(), reference.get_row_index());
}
return cell(&row[reference.get_column_index()]);
}
const cell worksheet::get_cell(const cell_reference &reference) const
{
return root_->get_cell(reference);
return cell(&d_->cell_map_.at(reference.get_row_index()).at(reference.get_column_index()));
}
range worksheet::get_named_range(const std::string &name)
{
return get_range(root_->parent_.get_named_range(name, *this).get_target_range());
if(!has_named_range(name))
{
throw std::runtime_error("named range not found for this worksheet");
}
return get_range(d_->named_ranges_[name]);
}
int worksheet::get_highest_row() const
column_t worksheet::get_lowest_column() const
{
return root_->get_highest_row();
if(d_->cell_map_.empty())
{
return 1;
}
column_t lowest = std::numeric_limits<column_t>::max();
for(auto &row : d_->cell_map_)
{
for(auto &c : row.second)
{
lowest = std::min(lowest, (column_t)c.first);
}
}
return lowest + 1;
}
int worksheet::get_highest_column() const
row_t worksheet::get_lowest_row() const
{
return root_->get_highest_column();
if(d_->cell_map_.empty())
{
return 1;
}
row_t lowest = std::numeric_limits<row_t>::max();
for(auto &row : d_->cell_map_)
{
lowest = std::min(lowest, (row_t)row.first);
}
return lowest + 1;
}
row_t worksheet::get_highest_row() const
{
row_t highest = 0;
for(auto &row : d_->cell_map_)
{
highest = std::max(highest, (row_t)row.first);
}
return highest + 1;
}
column_t worksheet::get_highest_column() const
{
column_t highest = 0;
for(auto &row : d_->cell_map_)
{
for(auto &c : row.second)
{
highest = std::max(highest, (column_t)c.first);
}
}
return highest + 1;
}
range_reference worksheet::calculate_dimension() const
{
return root_->calculate_dimension();
int lowest_column = get_lowest_column();
int lowest_row = get_lowest_row();
int highest_column = get_highest_column();
int highest_row = get_highest_row();
return range_reference(lowest_column - 1, lowest_row - 1, highest_column - 1, highest_row - 1);
}
range worksheet::get_range(const range_reference &reference)
{
return root_->get_range(reference);
return range(*this, reference);
}
const range worksheet::get_range(const range_reference &reference) const
{
return range(*this, reference);
}
std::vector<relationship> worksheet::get_relationships()
{
return root_->relationships_;
return d_->relationships_;
}
relationship worksheet::create_relationship(const std::string &relationship_type, const std::string &target_uri)
{
return root_->create_relationship(relationship_type, target_uri);
std::string r_id = "rId" + std::to_string(d_->relationships_.size() + 1);
d_->relationships_.push_back(relationship(relationship_type, r_id, target_uri));
return d_->relationships_.back();
}
//void worksheet::add_chart(chart chart);
void worksheet::merge_cells(const range_reference &reference)
{
root_->merge_cells(reference);
d_->merged_cells_.push_back(reference);
bool first = true;
for(auto row : get_range(reference))
{
for(auto cell : row)
{
cell.set_merged(true);
if(!first)
{
cell.bind_value();
}
first = false;
}
}
}
void worksheet::unmerge_cells(const range_reference &reference)
{
root_->unmerge_cells(reference);
auto match = std::find(d_->merged_cells_.begin(), d_->merged_cells_.end(), reference);
if(match == d_->merged_cells_.end())
{
throw std::runtime_error("cells not merged");
}
d_->merged_cells_.erase(match);
for(auto row : get_range(reference))
{
for(auto cell : row)
{
cell.set_merged(false);
}
}
}
void worksheet::append(const std::vector<std::string> &cells)
{
root_->append(cells);
int row = get_highest_row();
if(d_->cell_map_.size() == 0)
{
row--;
}
int column = 0;
for(auto cell : cells)
{
this->get_cell(cell_reference(column++, row)) = cell;
}
}
void worksheet::append(const std::unordered_map<std::string, std::string> &cells)
{
root_->append(cells);
int row = get_highest_row() - 1;
if(d_->cell_map_.size() != 0)
{
row++;
}
for(auto cell : cells)
{
this->get_cell(cell_reference(cell.first, row + 1)) = cell.second;
}
}
void worksheet::append(const std::unordered_map<int, std::string> &cells)
{
root_->append(cells);
int row = get_highest_row() - 1;
if(d_->cell_map_.size() != 0)
{
row++;
}
for(auto cell : cells)
{
this->get_cell(cell_reference(cell.first, row)) = cell.second;
}
}
xlnt::range worksheet::rows() const
{
return root_->rows();
return get_range(calculate_dimension());
}
bool worksheet::operator==(const worksheet &other) const
{
return root_ == other.root_;
return d_ == other.d_;
}
bool worksheet::operator!=(const worksheet &other) const
{
return root_ != other.root_;
return d_ != other.d_;
}
bool worksheet::operator==(std::nullptr_t) const
{
return root_ == nullptr;
return d_ == nullptr;
}
bool worksheet::operator!=(std::nullptr_t) const
{
return root_ != nullptr;
return d_ != nullptr;
}
void worksheet::operator=(const worksheet &other)
{
root_ = other.root_;
d_ = other.d_;
}
const cell worksheet::operator[](const cell_reference &ref) const
@ -517,26 +423,31 @@ range worksheet::operator[](const range_reference &ref)
range worksheet::operator[](const std::string &name)
{
if(root_->parent_.has_named_range(name, *this))
if(has_named_range(name))
{
return get_named_range(name);
}
return get_range(range_reference(name));
}
worksheet worksheet::allocate(xlnt::workbook &owner, const std::string &title)
bool worksheet::has_named_range(const std::string &name)
{
return new worksheet_struct(owner, title);
return d_->named_ranges_.find(name) != d_->named_ranges_.end();
}
void worksheet::deallocate(xlnt::worksheet ws)
void worksheet::remove_named_range(const std::string &name)
{
delete ws.root_;
if(!has_named_range(name))
{
throw std::runtime_error("worksheet doesn't have named range");
}
d_->named_ranges_.erase(name);
}
void worksheet::reserve(std::size_t n)
{
root_->cell_map_.reserve(n);
d_->cell_map_.reserve(n);
}
} // namespace xlnt

49
source/worksheet_impl.h Normal file
View File

@ -0,0 +1,49 @@
#include <string>
#include <unordered_map>
#include <vector>
#include "cell_impl.h"
namespace xlnt {
class workbook;
struct worksheet_impl
{
worksheet_impl(workbook *parent_workbook, const std::string &title)
: parent_(parent_workbook), title_(title), freeze_panes_("A1")
{
}
worksheet_impl(const worksheet_impl &other)
{
*this = other;
}
void operator=(const worksheet_impl &other)
{
parent_ = other.parent_;
title_ = other.title_;
freeze_panes_ = other.freeze_panes_;
cell_map_ = other.cell_map_;
relationships_ = other.relationships_;
page_setup_ = other.page_setup_;
auto_filter_ = other.auto_filter_;
page_margins_ = other.page_margins_;
merged_cells_ = other.merged_cells_;
named_ranges_ = other.named_ranges_;
}
workbook *parent_;
std::string title_;
cell_reference freeze_panes_;
std::unordered_map<int, std::unordered_map<int, cell_impl>> cell_map_;
std::vector<relationship> relationships_;
page_setup page_setup_;
range_reference auto_filter_;
margins page_margins_;
std::vector<range_reference> merged_cells_;
std::unordered_map<std::string, range_reference> named_ranges_;
};
} // namespace xlnt

0
include/xlnt/zip_file.h → source/zip_file.h
View File

79
tests/CellTestSuite.h
View File

@ -42,23 +42,32 @@ public:
void test_column_index()
{
TS_ASSERT_EQUALS(10, xlnt::cell_reference::column_index_from_string("J"));
TS_ASSERT_EQUALS(270, xlnt::cell_reference::column_index_from_string("jJ"));
TS_ASSERT_EQUALS(7030, xlnt::cell_reference::column_index_from_string("jjj"));
TS_ASSERT_EQUALS(1, xlnt::cell_reference::column_index_from_string("A"));
TS_ASSERT_EQUALS(26, xlnt::cell_reference::column_index_from_string("Z"));
TS_ASSERT_EQUALS(27, xlnt::cell_reference::column_index_from_string("AA"));
TS_ASSERT_EQUALS(52, xlnt::cell_reference::column_index_from_string("AZ"));
TS_ASSERT_EQUALS(53, xlnt::cell_reference::column_index_from_string("BA"));
TS_ASSERT_EQUALS(78, xlnt::cell_reference::column_index_from_string("BZ"));
TS_ASSERT_EQUALS(677, xlnt::cell_reference::column_index_from_string("ZA"));
TS_ASSERT_EQUALS(702, xlnt::cell_reference::column_index_from_string("ZZ"));
TS_ASSERT_EQUALS(703, xlnt::cell_reference::column_index_from_string("AAA"));
TS_ASSERT_EQUALS(728, xlnt::cell_reference::column_index_from_string("AAZ"));
TS_ASSERT_EQUALS(731, xlnt::cell_reference::column_index_from_string("ABC"));
TS_ASSERT_EQUALS(1353, xlnt::cell_reference::column_index_from_string("AZA"));
TS_ASSERT_EQUALS(18253, xlnt::cell_reference::column_index_from_string("ZZA"));
TS_ASSERT_EQUALS(18278, xlnt::cell_reference::column_index_from_string("ZZZ"));
static const std::unordered_map<int, std::string> expected =
{
{10, "J"},
{270, "jJ"},
{7030, "jjj"},
{1, "A"},
{26, "Z"},
{27, "AA"},
{52, "AZ"},
{53, "BA"},
{78, "BZ"},
{677, "ZA"},
{702, "ZZ"},
{703, "AAA"},
{728, "AAZ"},
{731, "ABC"},
{1353, "AZA"},
{18253, "ZZA"},
{18278, "ZZZ"}
};
for(auto expected_pair : expected)
{
auto calculated = xlnt::cell_reference::column_index_from_string(expected_pair.second);
TS_ASSERT_EQUALS(expected_pair.first, calculated);
}
}
void test_bad_column_index()
@ -90,7 +99,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1, "17.5");
xlnt::cell cell(ws, "A1", "17.5");
TS_ASSERT_EQUALS(xlnt::cell::type::numeric, cell.get_data_type());
}
@ -99,7 +108,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
TS_ASSERT_EQUALS(xlnt::cell::type::null, cell.get_data_type());
}
@ -108,7 +117,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1, "17.5");
xlnt::cell cell(ws, "A1", "17.5");
cell = 42;
TS_ASSERT_EQUALS(xlnt::cell::type::numeric, cell.get_data_type());
@ -140,7 +149,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = "hello";
TS_ASSERT_EQUALS(xlnt::cell::type::string, cell.get_data_type());
@ -150,7 +159,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = ".";
TS_ASSERT_EQUALS(xlnt::cell::type::string, cell.get_data_type());
}
@ -159,7 +168,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = "=42";
TS_ASSERT_EQUALS(xlnt::cell::type::formula, cell.get_data_type());
}
@ -168,7 +177,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = true;
TS_ASSERT_EQUALS(xlnt::cell::type::boolean, cell.get_data_type());
cell = false;
@ -179,7 +188,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = "0800";
TS_ASSERT_EQUALS(xlnt::cell::type::string, cell.get_data_type());
}
@ -188,7 +197,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
for(auto error : xlnt::cell::ErrorCodes)
{
@ -202,7 +211,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
TS_ASSERT_EQUALS(xlnt::cell::type::null, cell.get_data_type());
@ -220,7 +229,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell.set_explicit_value("1", xlnt::cell::type::formula);
}
@ -230,7 +239,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = "03:40:16";
TS_ASSERT_EQUALS(xlnt::cell::type::date, cell.get_data_type());
@ -252,7 +261,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
time_t t = time(0);
tm now = *localtime(&t);
@ -273,7 +282,7 @@ public:
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = today;
TS_ASSERT(today == cell);
@ -283,16 +292,16 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
TS_ASSERT_EQUALS(cell.to_string(), "<Cell Sheet1.A1>");
TS_ASSERT_EQUALS(cell.to_string(), "<Cell A1>");
}
void test_is_date()
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
time_t t = time(0);
tm now = *localtime(&t);
@ -309,7 +318,7 @@ public:
{
xlnt::workbook wb;
xlnt::worksheet ws = wb.get_active_sheet();
xlnt::cell cell(ws, "A", 1);
xlnt::cell cell(ws, "A1");
cell = -13.5;
//cell.get_style().get_number_format().set_format_code("0.00_);[Red]\\(0.00\\)");

27
tests/PasswordHashTestSuite.h
View File

@ -1,27 +0,0 @@
#pragma once
#include <iostream>
#include <cxxtest/TestSuite.h>
#include <xlnt/xlnt.h>
class PasswordHashTestSuite : public CxxTest::TestSuite
{
public:
PasswordHashTestSuite()
{
}
void test_hasher()
{
TS_ASSERT_EQUALS("CBEB", xlnt::sheet_protection::hash_password("test"));
}
void test_sheet_protection()
{
xlnt::sheet_protection protection;
protection.set_password("test");
TS_ASSERT_EQUALS("CBEB", protection.get_hashed_password());
}
};

53
tests/WorkbookTestSuite.h
View File

@ -45,10 +45,11 @@ public:
{
xlnt::workbook wb;
auto new_sheet = wb.create_sheet(0);
auto sheet_name = new_sheet.get_title();
wb.remove_sheet(new_sheet);
for(auto worksheet : wb)
{
TS_ASSERT_DIFFERS(new_sheet, worksheet);
TS_ASSERT_DIFFERS(sheet_name, worksheet.get_title());
}
}
@ -71,7 +72,7 @@ public:
auto found_sheet = wb.get_sheet_by_name(title);
TS_ASSERT_EQUALS(new_sheet, found_sheet);
TS_ASSERT_THROWS_ANYTHING(wb["NotThere"]);
TS_ASSERT_EQUALS(wb.get_sheet_by_name("NotThere"), nullptr);
}
void test_get_index2()
@ -121,23 +122,6 @@ public:
TS_ASSERT_EQUALS(new_sheet, wb[0]);
}
void test_create_sheet_readonly2()
{
xlnt::workbook wb(xlnt::optimization::read);
TS_ASSERT_THROWS_ANYTHING(wb.create_sheet());
}
void test_remove_sheet2()
{
xlnt::workbook wb;
auto new_sheet = wb.create_sheet(0);
wb.remove_sheet(new_sheet);
for(auto worksheet : wb)
{
TS_ASSERT_DIFFERS(new_sheet, worksheet);
}
}
void test_get_sheet_by_name2()
{
xlnt::workbook wb;
@ -160,28 +144,29 @@ public:
{
xlnt::workbook wb;
auto new_sheet = wb.create_sheet();
auto named_range = wb.create_named_range("test_nr", new_sheet, "A1");
auto named_ranges_list = wb.get_named_ranges();
TS_ASSERT_DIFFERS(std::find(named_ranges_list.begin(), named_ranges_list.end(), named_range), named_ranges_list.end());
wb.create_named_range("test_nr", new_sheet, "A1");
TS_ASSERT(new_sheet.has_named_range("test_nr"));
TS_ASSERT(wb.has_named_range("test_nr"));
}
void test_get_named_range2()
{
xlnt::workbook wb;
auto new_sheet = wb.create_sheet();
auto named_range = wb.create_named_range("test_nr", new_sheet, "A1");
auto found_named_range = wb.get_named_range("test_nr", new_sheet);
TS_ASSERT_EQUALS(named_range, found_named_range);
wb.create_named_range("test_nr", new_sheet, "A1");
auto found_range = wb.get_named_range("test_nr");
auto expected_range = new_sheet.get_range("A1");
TS_ASSERT_EQUALS(expected_range, found_range);
}
void test_remove_named_range()
{
xlnt::workbook wb;
auto new_sheet = wb.create_sheet();
auto named_range = wb.create_named_range("test_nr", new_sheet, "A1");
wb.remove_named_range(named_range);
auto named_ranges_list = wb.get_named_ranges();
TS_ASSERT_EQUALS(std::find(named_ranges_list.begin(), named_ranges_list.end(), named_range), named_ranges_list.end());
wb.create_named_range("test_nr", new_sheet, "A1");
wb.remove_named_range("test_nr");
TS_ASSERT(!new_sheet.has_named_range("test_nr"));
TS_ASSERT(!wb.has_named_range("test_nr"));
}
void test_add_local_named_range()
@ -193,16 +178,6 @@ public:
auto dest_filename = temp_file.GetFilename();
wb.save(dest_filename);
}
void make_tmpdir()
{
}
void clean_tmpdir()
{
}
void test_write_regular_date()
{

6
tests/WorksheetTestSuite.h
View File

@ -16,7 +16,7 @@ public:
void test_new_worksheet()
{
xlnt::worksheet ws = wb.create_sheet();
TS_ASSERT_EQUALS(&wb, &ws.get_parent());
TS_ASSERT(wb == ws.get_parent());
}
void test_new_sheet_name()
@ -95,7 +95,7 @@ public:
void test_cell_offset()
{
xlnt::worksheet ws(wb);
TS_ASSERT_EQUALS("C17", ws.get_cell("B15").get_offset(2, 1).get_reference().to_string());
TS_ASSERT_EQUALS("C17", ws.get_cell(xlnt::cell_reference("B15").make_offset(1, 2)).get_reference().to_string());
}
void test_range_offset()
@ -151,7 +151,7 @@ public:
void test_hyperlink_relationships()
{
xlnt::worksheet ws(wb);
TS_SKIP("test_hyperlink_relationships");
TS_ASSERT_EQUALS(ws.get_relationships().size(), 0);
ws.get_cell("A1").set_hyperlink("http:test.com");

84
tests/ZipFileTestSuite.h
View File

@ -1,84 +0,0 @@
#pragma once
#include <cxxtest/TestSuite.h>
#include <xlnt/xlnt.h>
#include "pugixml.hpp"
#include "PathHelper.h"
class ZipFileTestSuite : public CxxTest::TestSuite
{
public:
ZipFileTestSuite()
{
existing_zip = PathHelper::GetDataDirectory() + "/reader/a.zip";
existing_xlsx = PathHelper::GetDataDirectory() + "/reader/date_1900.xlsx";
new_xlsx = PathHelper::GetDataDirectory() + "/writer/new.xlsx";
}
void test_existing_package()
{
xlnt::zip_file package(existing_xlsx, xlnt::file_mode::open, xlnt::file_access::read);
}
void test_new_package()
{
xlnt::zip_file package(new_xlsx, xlnt::file_mode::create, xlnt::file_access::read_write);
}
void test_read_text()
{
xlnt::zip_file package(existing_xlsx, xlnt::file_mode::open, xlnt::file_access::read);
auto contents = package.get_file_contents("xl/_rels/workbook.xml.rels");
auto expected = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n"
"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
"<Relationship Id=\"rId3\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet3.xml\"/>"
"<Relationship Id=\"rId4\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"theme/theme1.xml\"/>"
"<Relationship Id=\"rId5\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>"
"<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet1.xml\"/>"
"<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet2.xml\"/>"
"</Relationships>";
TS_ASSERT_EQUALS(contents, expected);
}
void test_write_text()
{
{
xlnt::zip_file package(new_xlsx, xlnt::file_mode::create, xlnt::file_access::write);
package.set_file_contents("a.txt", "something else");
}
{
xlnt::zip_file package(new_xlsx, xlnt::file_mode::open, xlnt::file_access::read);
auto contents = package.get_file_contents("a.txt");
TS_ASSERT_EQUALS(contents, "something else");
}
}
void test_read_xml()
{
xlnt::zip_file package(existing_zip, xlnt::file_mode::open, xlnt::file_access::read);
auto contents = package.get_file_contents("a.xml");
pugi::xml_document doc;
doc.load(contents.c_str());
auto root_element = doc.child("root");
TS_ASSERT_DIFFERS(root_element, nullptr)
auto child_element = root_element.child("child");
TS_ASSERT_DIFFERS(child_element, nullptr)
TS_ASSERT_EQUALS(std::string(child_element.attribute("attribute").as_string()), "attribute")
auto element_element = root_element.child("element");
TS_ASSERT_DIFFERS(element_element, nullptr)
TS_ASSERT_EQUALS(std::string(element_element.text().as_string()), "Text")
}
private:
std::string existing_zip;
std::string existing_xlsx;
std::string new_xlsx;
};

164
tests/runner-autogen.cpp
View File

@ -21,7 +21,7 @@ int main( int argc, char *argv[] ) {
return status;
}
bool suite_CellTestSuite_init = false;
#include "/home/thomas/Development/xlnt/tests/CellTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/CellTestSuite.h"
static CellTestSuite suite_CellTestSuite;
@ -66,125 +66,125 @@ public:
static class TestDescription_suite_CellTestSuite_test_bad_column_index : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_bad_column_index() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 64, "test_bad_column_index" ) {}
TestDescription_suite_CellTestSuite_test_bad_column_index() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 73, "test_bad_column_index" ) {}
void runTest() { suite_CellTestSuite.test_bad_column_index(); }
} testDescription_suite_CellTestSuite_test_bad_column_index;
static class TestDescription_suite_CellTestSuite_test_column_letter_boundries : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_column_letter_boundries() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 72, "test_column_letter_boundries" ) {}
TestDescription_suite_CellTestSuite_test_column_letter_boundries() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 81, "test_column_letter_boundries" ) {}
void runTest() { suite_CellTestSuite.test_column_letter_boundries(); }
} testDescription_suite_CellTestSuite_test_column_letter_boundries;
static class TestDescription_suite_CellTestSuite_test_column_letter : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_column_letter() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 79, "test_column_letter" ) {}
TestDescription_suite_CellTestSuite_test_column_letter() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 88, "test_column_letter" ) {}
void runTest() { suite_CellTestSuite.test_column_letter(); }
} testDescription_suite_CellTestSuite_test_column_letter;
static class TestDescription_suite_CellTestSuite_test_initial_value : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_initial_value() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 89, "test_initial_value" ) {}
TestDescription_suite_CellTestSuite_test_initial_value() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 98, "test_initial_value" ) {}
void runTest() { suite_CellTestSuite.test_initial_value(); }
} testDescription_suite_CellTestSuite_test_initial_value;
static class TestDescription_suite_CellTestSuite_test_null : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_null() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 98, "test_null" ) {}
TestDescription_suite_CellTestSuite_test_null() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 107, "test_null" ) {}
void runTest() { suite_CellTestSuite.test_null(); }
} testDescription_suite_CellTestSuite_test_null;
static class TestDescription_suite_CellTestSuite_test_numeric : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_numeric() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 107, "test_numeric" ) {}
TestDescription_suite_CellTestSuite_test_numeric() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 116, "test_numeric" ) {}
void runTest() { suite_CellTestSuite.test_numeric(); }
} testDescription_suite_CellTestSuite_test_numeric;
static class TestDescription_suite_CellTestSuite_test_string : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_string() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 139, "test_string" ) {}
TestDescription_suite_CellTestSuite_test_string() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 148, "test_string" ) {}
void runTest() { suite_CellTestSuite.test_string(); }
} testDescription_suite_CellTestSuite_test_string;
static class TestDescription_suite_CellTestSuite_test_single_dot : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_single_dot() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 149, "test_single_dot" ) {}
TestDescription_suite_CellTestSuite_test_single_dot() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 158, "test_single_dot" ) {}
void runTest() { suite_CellTestSuite.test_single_dot(); }
} testDescription_suite_CellTestSuite_test_single_dot;
static class TestDescription_suite_CellTestSuite_test_formula : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_formula() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 158, "test_formula" ) {}
TestDescription_suite_CellTestSuite_test_formula() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 167, "test_formula" ) {}
void runTest() { suite_CellTestSuite.test_formula(); }
} testDescription_suite_CellTestSuite_test_formula;
static class TestDescription_suite_CellTestSuite_test_boolean : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_boolean() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 167, "test_boolean" ) {}
TestDescription_suite_CellTestSuite_test_boolean() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 176, "test_boolean" ) {}
void runTest() { suite_CellTestSuite.test_boolean(); }
} testDescription_suite_CellTestSuite_test_boolean;
static class TestDescription_suite_CellTestSuite_test_leading_zero : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_leading_zero() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 178, "test_leading_zero" ) {}
TestDescription_suite_CellTestSuite_test_leading_zero() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 187, "test_leading_zero" ) {}
void runTest() { suite_CellTestSuite.test_leading_zero(); }
} testDescription_suite_CellTestSuite_test_leading_zero;
static class TestDescription_suite_CellTestSuite_test_error_codes : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_error_codes() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 187, "test_error_codes" ) {}
TestDescription_suite_CellTestSuite_test_error_codes() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 196, "test_error_codes" ) {}
void runTest() { suite_CellTestSuite.test_error_codes(); }
} testDescription_suite_CellTestSuite_test_error_codes;
static class TestDescription_suite_CellTestSuite_test_data_type_check : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_data_type_check() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 201, "test_data_type_check" ) {}
TestDescription_suite_CellTestSuite_test_data_type_check() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 210, "test_data_type_check" ) {}
void runTest() { suite_CellTestSuite.test_data_type_check(); }
} testDescription_suite_CellTestSuite_test_data_type_check;
static class TestDescription_suite_CellTestSuite_test_set_bad_type : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_set_bad_type() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 219, "test_set_bad_type" ) {}
TestDescription_suite_CellTestSuite_test_set_bad_type() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 228, "test_set_bad_type" ) {}
void runTest() { suite_CellTestSuite.test_set_bad_type(); }
} testDescription_suite_CellTestSuite_test_set_bad_type;
static class TestDescription_suite_CellTestSuite_test_time : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_time() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 229, "test_time" ) {}
TestDescription_suite_CellTestSuite_test_time() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 238, "test_time" ) {}
void runTest() { suite_CellTestSuite.test_time(); }
} testDescription_suite_CellTestSuite_test_time;
static class TestDescription_suite_CellTestSuite_test_date_format_on_non_date : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_date_format_on_non_date() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 251, "test_date_format_on_non_date" ) {}
TestDescription_suite_CellTestSuite_test_date_format_on_non_date() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 260, "test_date_format_on_non_date" ) {}
void runTest() { suite_CellTestSuite.test_date_format_on_non_date(); }
} testDescription_suite_CellTestSuite_test_date_format_on_non_date;
static class TestDescription_suite_CellTestSuite_test_set_get_date : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_set_get_date() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 264, "test_set_get_date" ) {}
TestDescription_suite_CellTestSuite_test_set_get_date() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 273, "test_set_get_date" ) {}
void runTest() { suite_CellTestSuite.test_set_get_date(); }
} testDescription_suite_CellTestSuite_test_set_get_date;
static class TestDescription_suite_CellTestSuite_test_repr : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_repr() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 282, "test_repr" ) {}
TestDescription_suite_CellTestSuite_test_repr() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 291, "test_repr" ) {}
void runTest() { suite_CellTestSuite.test_repr(); }
} testDescription_suite_CellTestSuite_test_repr;
static class TestDescription_suite_CellTestSuite_test_is_date : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_is_date() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 291, "test_is_date" ) {}
TestDescription_suite_CellTestSuite_test_is_date() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 300, "test_is_date" ) {}
void runTest() { suite_CellTestSuite.test_is_date(); }
} testDescription_suite_CellTestSuite_test_is_date;
static class TestDescription_suite_CellTestSuite_test_is_not_date_color_format : public CxxTest::RealTestDescription {
public:
TestDescription_suite_CellTestSuite_test_is_not_date_color_format() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 308, "test_is_not_date_color_format" ) {}
TestDescription_suite_CellTestSuite_test_is_not_date_color_format() : CxxTest::RealTestDescription( Tests_CellTestSuite, suiteDescription_CellTestSuite, 317, "test_is_not_date_color_format" ) {}
void runTest() { suite_CellTestSuite.test_is_not_date_color_format(); }
} testDescription_suite_CellTestSuite_test_is_not_date_color_format;
#include "/home/thomas/Development/xlnt/tests/ChartTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/ChartTestSuite.h"
static ChartTestSuite suite_ChartTestSuite;
@ -275,7 +275,7 @@ public:
void runTest() { suite_ChartTestSuite.test_write_chart_scatter(); }
} testDescription_suite_ChartTestSuite_test_write_chart_scatter;
#include "/home/thomas/Development/xlnt/tests/DumpTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/DumpTestSuite.h"
static DumpTestSuite suite_DumpTestSuite;
@ -318,7 +318,7 @@ public:
void runTest() { suite_DumpTestSuite.test_append_after_save(); }
} testDescription_suite_DumpTestSuite_test_append_after_save;
#include "/home/thomas/Development/xlnt/tests/NamedRangeTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/NamedRangeTestSuite.h"
static NamedRangeTestSuite suite_NamedRangeTestSuite;
@ -409,7 +409,7 @@ public:
void runTest() { suite_NamedRangeTestSuite.test_can_be_saved(); }
} testDescription_suite_NamedRangeTestSuite_test_can_be_saved;
#include "/home/thomas/Development/xlnt/tests/NumberFormatTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/NumberFormatTestSuite.h"
static NumberFormatTestSuite suite_NumberFormatTestSuite;
@ -512,26 +512,7 @@ public:
void runTest() { suite_NumberFormatTestSuite.test_mac_date(); }
} testDescription_suite_NumberFormatTestSuite_test_mac_date;
#include "/home/thomas/Development/xlnt/tests/PasswordHashTestSuite.h"
static PasswordHashTestSuite suite_PasswordHashTestSuite;
static CxxTest::List Tests_PasswordHashTestSuite = { 0, 0 };
CxxTest::StaticSuiteDescription suiteDescription_PasswordHashTestSuite( "../../tests/PasswordHashTestSuite.h", 8, "PasswordHashTestSuite", suite_PasswordHashTestSuite, Tests_PasswordHashTestSuite );
static class TestDescription_suite_PasswordHashTestSuite_test_hasher : public CxxTest::RealTestDescription {
public:
TestDescription_suite_PasswordHashTestSuite_test_hasher() : CxxTest::RealTestDescription( Tests_PasswordHashTestSuite, suiteDescription_PasswordHashTestSuite, 16, "test_hasher" ) {}
void runTest() { suite_PasswordHashTestSuite.test_hasher(); }
} testDescription_suite_PasswordHashTestSuite_test_hasher;
static class TestDescription_suite_PasswordHashTestSuite_test_sheet_protection : public CxxTest::RealTestDescription {
public:
TestDescription_suite_PasswordHashTestSuite_test_sheet_protection() : CxxTest::RealTestDescription( Tests_PasswordHashTestSuite, suiteDescription_PasswordHashTestSuite, 21, "test_sheet_protection" ) {}
void runTest() { suite_PasswordHashTestSuite.test_sheet_protection(); }
} testDescription_suite_PasswordHashTestSuite_test_sheet_protection;
#include "/home/thomas/Development/xlnt/tests/PropsTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/PropsTestSuite.h"
static PropsTestSuite suite_PropsTestSuite;
@ -574,7 +555,7 @@ public:
void runTest() { suite_PropsTestSuite.test_write_properties_app(); }
} testDescription_suite_PropsTestSuite_test_write_properties_app;
#include "/home/thomas/Development/xlnt/tests/ReadTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/ReadTestSuite.h"
static ReadTestSuite suite_ReadTestSuite;
@ -707,7 +688,7 @@ public:
void runTest() { suite_ReadTestSuite.test_read_date_value(); }
} testDescription_suite_ReadTestSuite_test_read_date_value;
#include "/home/thomas/Development/xlnt/tests/StringsTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/StringsTestSuite.h"
static StringsTestSuite suite_StringsTestSuite;
@ -738,7 +719,7 @@ public:
void runTest() { suite_StringsTestSuite.test_formatted_string_table(); }
} testDescription_suite_StringsTestSuite_test_formatted_string_table;
#include "/home/thomas/Development/xlnt/tests/StyleTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/StyleTestSuite.h"
static StyleTestSuite suite_StyleTestSuite;
@ -835,7 +816,7 @@ public:
void runTest() { suite_StyleTestSuite.test_read_cell_style(); }
} testDescription_suite_StyleTestSuite_test_read_cell_style;
#include "/home/thomas/Development/xlnt/tests/ThemeTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/ThemeTestSuite.h"
static ThemeTestSuite suite_ThemeTestSuite;
@ -848,7 +829,7 @@ public:
void runTest() { suite_ThemeTestSuite.test_write_theme(); }
} testDescription_suite_ThemeTestSuite_test_write_theme;
#include "/home/thomas/Development/xlnt/tests/WorkbookTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/WorkbookTestSuite.h"
static WorkbookTestSuite suite_WorkbookTestSuite;
@ -887,107 +868,95 @@ public:
static class TestDescription_suite_WorkbookTestSuite_test_get_sheet_by_name : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_get_sheet_by_name() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 55, "test_get_sheet_by_name" ) {}
TestDescription_suite_WorkbookTestSuite_test_get_sheet_by_name() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 56, "test_get_sheet_by_name" ) {}
void runTest() { suite_WorkbookTestSuite.test_get_sheet_by_name(); }
} testDescription_suite_WorkbookTestSuite_test_get_sheet_by_name;
static class TestDescription_suite_WorkbookTestSuite_test_getitem : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_getitem() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 65, "test_getitem" ) {}
TestDescription_suite_WorkbookTestSuite_test_getitem() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 66, "test_getitem" ) {}
void runTest() { suite_WorkbookTestSuite.test_getitem(); }
} testDescription_suite_WorkbookTestSuite_test_getitem;
static class TestDescription_suite_WorkbookTestSuite_test_get_index2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_get_index2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 77, "test_get_index2" ) {}
TestDescription_suite_WorkbookTestSuite_test_get_index2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 78, "test_get_index2" ) {}
void runTest() { suite_WorkbookTestSuite.test_get_index2(); }
} testDescription_suite_WorkbookTestSuite_test_get_index2;
static class TestDescription_suite_WorkbookTestSuite_test_get_sheet_names : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_get_sheet_names() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 85, "test_get_sheet_names" ) {}
TestDescription_suite_WorkbookTestSuite_test_get_sheet_names() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 86, "test_get_sheet_names" ) {}
void runTest() { suite_WorkbookTestSuite.test_get_sheet_names(); }
} testDescription_suite_WorkbookTestSuite_test_get_sheet_names;
static class TestDescription_suite_WorkbookTestSuite_test_get_active_sheet2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_get_active_sheet2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 103, "test_get_active_sheet2" ) {}
TestDescription_suite_WorkbookTestSuite_test_get_active_sheet2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 104, "test_get_active_sheet2" ) {}
void runTest() { suite_WorkbookTestSuite.test_get_active_sheet2(); }
} testDescription_suite_WorkbookTestSuite_test_get_active_sheet2;
static class TestDescription_suite_WorkbookTestSuite_test_create_sheet2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_create_sheet2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 110, "test_create_sheet2" ) {}
TestDescription_suite_WorkbookTestSuite_test_create_sheet2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 111, "test_create_sheet2" ) {}
void runTest() { suite_WorkbookTestSuite.test_create_sheet2(); }
} testDescription_suite_WorkbookTestSuite_test_create_sheet2;
static class TestDescription_suite_WorkbookTestSuite_test_create_sheet_with_name2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_create_sheet_with_name2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 117, "test_create_sheet_with_name2" ) {}
TestDescription_suite_WorkbookTestSuite_test_create_sheet_with_name2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 118, "test_create_sheet_with_name2" ) {}
void runTest() { suite_WorkbookTestSuite.test_create_sheet_with_name2(); }
} testDescription_suite_WorkbookTestSuite_test_create_sheet_with_name2;
static class TestDescription_suite_WorkbookTestSuite_test_create_sheet_readonly2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_create_sheet_readonly2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 124, "test_create_sheet_readonly2" ) {}
void runTest() { suite_WorkbookTestSuite.test_create_sheet_readonly2(); }
} testDescription_suite_WorkbookTestSuite_test_create_sheet_readonly2;
static class TestDescription_suite_WorkbookTestSuite_test_remove_sheet2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_remove_sheet2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 130, "test_remove_sheet2" ) {}
void runTest() { suite_WorkbookTestSuite.test_remove_sheet2(); }
} testDescription_suite_WorkbookTestSuite_test_remove_sheet2;
static class TestDescription_suite_WorkbookTestSuite_test_get_sheet_by_name2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_get_sheet_by_name2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 141, "test_get_sheet_by_name2" ) {}
TestDescription_suite_WorkbookTestSuite_test_get_sheet_by_name2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 125, "test_get_sheet_by_name2" ) {}
void runTest() { suite_WorkbookTestSuite.test_get_sheet_by_name2(); }
} testDescription_suite_WorkbookTestSuite_test_get_sheet_by_name2;
static class TestDescription_suite_WorkbookTestSuite_test_get_index : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_get_index() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 151, "test_get_index" ) {}
TestDescription_suite_WorkbookTestSuite_test_get_index() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 135, "test_get_index" ) {}
void runTest() { suite_WorkbookTestSuite.test_get_index(); }
} testDescription_suite_WorkbookTestSuite_test_get_index;
static class TestDescription_suite_WorkbookTestSuite_test_add_named_range : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_add_named_range() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 159, "test_add_named_range" ) {}
TestDescription_suite_WorkbookTestSuite_test_add_named_range() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 143, "test_add_named_range" ) {}
void runTest() { suite_WorkbookTestSuite.test_add_named_range(); }
} testDescription_suite_WorkbookTestSuite_test_add_named_range;
static class TestDescription_suite_WorkbookTestSuite_test_get_named_range2 : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_get_named_range2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 168, "test_get_named_range2" ) {}
TestDescription_suite_WorkbookTestSuite_test_get_named_range2() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 152, "test_get_named_range2" ) {}
void runTest() { suite_WorkbookTestSuite.test_get_named_range2(); }
} testDescription_suite_WorkbookTestSuite_test_get_named_range2;
static class TestDescription_suite_WorkbookTestSuite_test_remove_named_range : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_remove_named_range() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 177, "test_remove_named_range" ) {}
TestDescription_suite_WorkbookTestSuite_test_remove_named_range() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 162, "test_remove_named_range" ) {}
void runTest() { suite_WorkbookTestSuite.test_remove_named_range(); }
} testDescription_suite_WorkbookTestSuite_test_remove_named_range;
static class TestDescription_suite_WorkbookTestSuite_test_add_local_named_range : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_add_local_named_range() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 187, "test_add_local_named_range" ) {}
TestDescription_suite_WorkbookTestSuite_test_add_local_named_range() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 172, "test_add_local_named_range" ) {}
void runTest() { suite_WorkbookTestSuite.test_add_local_named_range(); }
} testDescription_suite_WorkbookTestSuite_test_add_local_named_range;
static class TestDescription_suite_WorkbookTestSuite_test_write_regular_date : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_write_regular_date() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 207, "test_write_regular_date" ) {}
TestDescription_suite_WorkbookTestSuite_test_write_regular_date() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 182, "test_write_regular_date" ) {}
void runTest() { suite_WorkbookTestSuite.test_write_regular_date(); }
} testDescription_suite_WorkbookTestSuite_test_write_regular_date;
static class TestDescription_suite_WorkbookTestSuite_test_write_regular_float : public CxxTest::RealTestDescription {
public:
TestDescription_suite_WorkbookTestSuite_test_write_regular_float() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 225, "test_write_regular_float" ) {}
TestDescription_suite_WorkbookTestSuite_test_write_regular_float() : CxxTest::RealTestDescription( Tests_WorkbookTestSuite, suiteDescription_WorkbookTestSuite, 200, "test_write_regular_float" ) {}
void runTest() { suite_WorkbookTestSuite.test_write_regular_float(); }
} testDescription_suite_WorkbookTestSuite_test_write_regular_float;
#include "/home/thomas/Development/xlnt/tests/WorksheetTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/WorksheetTestSuite.h"
static WorksheetTestSuite suite_WorksheetTestSuite;
@ -1156,7 +1125,7 @@ public:
void runTest() { suite_WorksheetTestSuite.test_printer_settings(); }
} testDescription_suite_WorksheetTestSuite_test_printer_settings;
#include "/home/thomas/Development/xlnt/tests/WriteTestSuite.h"
#include "/Users/thomas/Development/xlnt/tests/WriteTestSuite.h"
static WriteTestSuite suite_WriteTestSuite;
@ -1289,42 +1258,5 @@ public:
void runTest() { suite_WriteTestSuite.test_short_number(); }
} testDescription_suite_WriteTestSuite_test_short_number;
#include "/home/thomas/Development/xlnt/tests/ZipFileTestSuite.h"
static ZipFileTestSuite suite_ZipFileTestSuite;
static CxxTest::List Tests_ZipFileTestSuite = { 0, 0 };
CxxTest::StaticSuiteDescription suiteDescription_ZipFileTestSuite( "../../tests/ZipFileTestSuite.h", 9, "ZipFileTestSuite", suite_ZipFileTestSuite, Tests_ZipFileTestSuite );
static class TestDescription_suite_ZipFileTestSuite_test_existing_package : public CxxTest::RealTestDescription {
public:
TestDescription_suite_ZipFileTestSuite_test_existing_package() : CxxTest::RealTestDescription( Tests_ZipFileTestSuite, suiteDescription_ZipFileTestSuite, 19, "test_existing_package" ) {}
void runTest() { suite_ZipFileTestSuite.test_existing_package(); }
} testDescription_suite_ZipFileTestSuite_test_existing_package;
static class TestDescription_suite_ZipFileTestSuite_test_new_package : public CxxTest::RealTestDescription {
public:
TestDescription_suite_ZipFileTestSuite_test_new_package() : CxxTest::RealTestDescription( Tests_ZipFileTestSuite, suiteDescription_ZipFileTestSuite, 24, "test_new_package" ) {}
void runTest() { suite_ZipFileTestSuite.test_new_package(); }
} testDescription_suite_ZipFileTestSuite_test_new_package;
static class TestDescription_suite_ZipFileTestSuite_test_read_text : public CxxTest::RealTestDescription {
public:
TestDescription_suite_ZipFileTestSuite_test_read_text() : CxxTest::RealTestDescription( Tests_ZipFileTestSuite, suiteDescription_ZipFileTestSuite, 29, "test_read_text" ) {}
void runTest() { suite_ZipFileTestSuite.test_read_text(); }
} testDescription_suite_ZipFileTestSuite_test_read_text;
static class TestDescription_suite_ZipFileTestSuite_test_write_text : public CxxTest::RealTestDescription {
public:
TestDescription_suite_ZipFileTestSuite_test_write_text() : CxxTest::RealTestDescription( Tests_ZipFileTestSuite, suiteDescription_ZipFileTestSuite, 44, "test_write_text" ) {}
void runTest() { suite_ZipFileTestSuite.test_write_text(); }
} testDescription_suite_ZipFileTestSuite_test_write_text;
static class TestDescription_suite_ZipFileTestSuite_test_read_xml : public CxxTest::RealTestDescription {
public:
TestDescription_suite_ZipFileTestSuite_test_read_xml() : CxxTest::RealTestDescription( Tests_ZipFileTestSuite, suiteDescription_ZipFileTestSuite, 58, "test_read_xml" ) {}
void runTest() { suite_ZipFileTestSuite.test_read_xml(); }
} testDescription_suite_ZipFileTestSuite_test_read_xml;
#include <cxxtest/Root.cpp>
const char* CxxTest::RealWorldDescription::_worldName = "cxxtest";