xlnt/source/detail/cell_impl.hpp

206 lines
4.9 KiB
C++
Raw Normal View History

2014-05-31 06:42:25 +08:00
#pragma once
#include <cstdlib>
2014-08-14 06:56:34 +08:00
#include <xlnt/cell/cell.hpp>
#include <xlnt/cell/comment.hpp>
#include <xlnt/common/exceptions.hpp>
#include <xlnt/common/datetime.hpp>
2014-08-14 06:56:34 +08:00
#include <xlnt/common/types.hpp>
#include <xlnt/common/relationship.hpp>
2015-10-19 03:30:46 +08:00
#include <xlnt/styles/number_format.hpp>
2014-05-31 06:42:25 +08:00
#include "comment_impl.hpp"
namespace {
// return s after checking encoding, size, and illegal characters
std::string check_string(std::string s)
{
if (s.size() == 0)
{
return s;
}
// check encoding?
if (s.size() > 32767)
{
s = s.substr(0, 32767); // max string length in Excel
}
2015-10-15 06:05:13 +08:00
for (char c : s)
{
2015-10-15 06:05:13 +08:00
if (c>= 0 && (c <= 8 || c == 11 || c == 12 || (c >= 14 && c <= 31)))
{
2015-10-15 06:05:13 +08:00
throw xlnt::illegal_character_error(c);
}
}
return s;
}
std::pair<bool, long double> cast_numeric(const std::string &s)
{
const char *str = s.c_str();
char *str_end = nullptr;
auto result = std::strtold(str, &str_end);
if (str_end != str + s.size()) return{ false, 0 };
return{ true, result };
}
std::pair<bool, long double> cast_percentage(const std::string &s)
{
if (s.back() == '%')
{
auto number = cast_numeric(s.substr(0, s.size() - 1));
if (number.first)
{
return{ true, number.second / 100 };
}
}
return { false, 0 };
}
std::pair<bool, xlnt::time> cast_time(const std::string &s)
{
xlnt::time result;
try
{
auto last_colon = s.find_last_of(':');
if (last_colon == std::string::npos) return { false, result };
double seconds = std::stod(s.substr(last_colon + 1));
result.second = static_cast<int>(seconds);
result.microsecond = static_cast<int>((seconds - static_cast<double>(result.second)) * 1e6);
auto first_colon = s.find_first_of(':');
if (first_colon == last_colon)
{
auto decimal_pos = s.find('.');
if (decimal_pos != std::string::npos)
{
result.minute = std::stoi(s.substr(0, first_colon));
}
else
{
result.hour = std::stoi(s.substr(0, first_colon));
result.minute = result.second;
result.second = 0;
}
}
else
{
result.hour = std::stoi(s.substr(0, first_colon));
result.minute = std::stoi(s.substr(first_colon + 1, last_colon - first_colon - 1));
}
}
catch (std::invalid_argument)
{
return{ false, result };
}
return { true, result };
}
} // namespace
2014-05-31 06:42:25 +08:00
namespace xlnt {
class style;
namespace detail {
2014-06-06 05:42:15 +08:00
struct worksheet_impl;
2014-05-31 06:42:25 +08:00
struct cell_impl
{
cell_impl();
cell_impl(column_t column, row_t row);
cell_impl(worksheet_impl *parent, column_t column, row_t row);
cell_impl(const cell_impl &rhs);
cell_impl &operator=(const cell_impl &rhs);
2015-10-19 03:30:46 +08:00
cell self()
{
2015-10-19 03:30:46 +08:00
return xlnt::cell(this);
}
void set_string(const std::string &s, bool guess_types)
{
value_string_ = check_string(s);
type_ = cell::type::string;
if (value_string_.size() > 1 && value_string_.front() == '=')
{
formula_ = value_string_;
type_ = cell::type::formula;
value_string_.clear();
}
2015-10-30 01:46:56 +08:00
else if(cell::error_codes().find(s) != cell::error_codes().end())
{
type_ = cell::type::error;
}
else if(guess_types)
{
auto percentage = cast_percentage(s);
if (percentage.first)
{
value_numeric_ = percentage.second;
type_ = cell::type::numeric;
2015-10-24 02:42:36 +08:00
self().set_number_format(xlnt::number_format::percentage());
}
else
{
auto time = cast_time(s);
if (time.first)
{
2015-10-19 03:30:46 +08:00
type_ = cell::type::numeric;
2015-10-24 02:42:36 +08:00
self().set_number_format(number_format::date_time6());
2015-10-19 03:30:46 +08:00
value_numeric_ = time.second.to_number();
}
else
{
auto numeric = cast_numeric(s);
if (numeric.first)
{
value_numeric_ = numeric.second;
type_ = cell::type::numeric;
}
}
}
}
}
cell::type type_;
2014-06-06 05:42:15 +08:00
worksheet_impl *parent_;
2014-07-26 04:39:25 +08:00
column_t column_;
row_t row_;
std::string value_string_;
long double value_numeric_;
std::string formula_;
2014-06-12 04:41:34 +08:00
bool has_hyperlink_;
relationship hyperlink_;
bool is_merged_;
2015-10-21 01:53:47 +08:00
bool has_style_;
2015-10-19 03:30:46 +08:00
std::size_t style_id_;
std::unique_ptr<comment_impl> comment_;
2014-05-31 06:42:25 +08:00
};
} // namespace detail
} // namespace xlnt