xlnt/source/styles/number_format.cpp
2016-06-24 10:43:51 +01:00

1277 lines
36 KiB
C++

// Copyright (c) 2014-2016 Thomas Fussell
// Copyright (c) 2010-2015 openpyxl
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, WRISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
//
// @license: http://www.opensource.org/licenses/mit-license.php
// @author: see AUTHORS file
#include <algorithm>
#include <cctype>
#include <unordered_map>
#include <vector>
#include <xlnt/utils/datetime.hpp>
#include <xlnt/utils/hash_combine.hpp>
#include <xlnt/styles/number_format.hpp>
namespace {
const std::unordered_map<std::size_t, std::string> &builtin_formats()
{
static const std::unordered_map<std::size_t, std::string> *formats =
new std::unordered_map<std::size_t, std::string>
({
{ 0, "General" },
{ 1, "0" },
{ 2, "0.00" },
{ 3, "#,##0" },
{ 4, "#,##0.00" },
{ 5, "\"$\"#,##0_);(\"$\"#,##0)" },
{ 6, "\"$\"#,##0_);[Red](\"$\"#,##0)" },
{ 7, "\"$\"#,##0.00_);(\"$\"#,##0.00)" },
{ 8, "\"$\"#,##0.00_);[Red](\"$\"#,##0.00)" },
{ 9, "0%" },
{ 10, "0.00%" },
{ 11, "0.00E+00" },
{ 12, "# ?/?" },
{ 13, "# \?\?/??" }, // escape trigraph
{ 14, "mm-dd-yy" },
{ 15, "d-mmm-yy" },
{ 16, "d-mmm" },
{ 17, "mmm-yy" },
{ 18, "h:mm AM/PM" },
{ 19, "h:mm:ss AM/PM" },
{ 20, "h:mm" },
{ 21, "h:mm:ss" },
{ 22, "m/d/yy h:mm" },
{ 37, "#,##0_);(#,##0)" },
{ 38, "#,##0_);[Red](#,##0)" },
{ 39, "#,##0.00_);(#,##0.00)" },
{ 40, "#,##0.00_);[Red](#,##0.00)" },
{ 41, "_(* #,##0_);_(* \\(#,##0\\);_(* \"-\"_);_(@_)" },
{ 42, "_(\"$\"* #,##0_);_(\"$\"* \\(#,##0\\);_(\"$\"* \"-\"_);_(@_)" },
{ 43, "_(* #,##0.00_);_(* \\(#,##0.00\\);_(* \"-\"??_);_(@_)" },
{ 44, "_-\"$\"* #,##0.00_-;\\-\"$\"* #,##0.00_-;_-\"$\"* \"-\"??_-;_-@_-" },
{ 45, "mm:ss" },
{ 46, "[h]:mm:ss" },
{ 47, "mmss.0" },
{ 48, "##0.0E+0" },
{ 49, "@" }
// EXCEL differs from the standard in the following:
//{14, "m/d/yyyy"},
//{22, "m/d/yyyy h:mm"},
//{37, "#,##0_);(#,##0)"},
//{38, "#,##0_);[Red]"},
//{39, "#,##0.00_);(#,##0.00)"},
//{40, "#,##0.00_);[Red]"},
//{47, "mm:ss.0"},
//{55, "yyyy/mm/dd"}
});
return *formats;
}
enum class condition_type
{
less_than,
less_or_equal,
equal,
greater_than,
greater_or_equal,
invalid
};
struct section
{
bool has_value = false;
std::string value;
bool has_color = false;
std::string color;
bool has_condition = false;
condition_type condition = condition_type::invalid;
std::string condition_value;
bool has_locale = false;
std::string locale;
section &operator=(const section &other)
{
has_value = other.has_value;
value = other.value;
has_color = other.has_color;
color = other.color;
has_condition = other.has_condition;
condition = other.condition;
condition_value = other.condition_value;
has_locale = other.has_locale;
locale = other.locale;
return *this;
}
};
struct format_sections
{
section first;
section second;
section third;
section fourth;
};
// copied from named_range.cpp, keep in sync
/// <summary>
/// Return a vector containing string split at each delim.
/// </summary>
/// <remark>
/// This should maybe be in a utility header so it can be used elsewhere.
/// </remarks>
std::vector<std::string> split_string(const std::string &string, char delim)
{
std::vector<std::string> split;
std::string::size_type previous_index = 0;
auto separator_index = string.find(delim);
while (separator_index != std::string::npos)
{
auto part = string.substr(previous_index, separator_index - previous_index);
split.push_back(part);
previous_index = separator_index + 1;
separator_index = string.find(delim, previous_index);
}
split.push_back(string.substr(previous_index));
return split;
}
std::vector<std::string> split_string_any(const std::string &string, const std::string &delims)
{
std::vector<std::string> split;
std::string::size_type previous_index = 0;
auto separator_index = string.find_first_of(delims);
while (separator_index != std::string::npos)
{
auto part = string.substr(previous_index, separator_index - previous_index);
if (!part.empty())
{
split.push_back(part);
}
previous_index = separator_index + 1;
separator_index = string.find_first_of(delims, previous_index);
}
split.push_back(string.substr(previous_index));
return split;
}
bool is_date_format(const std::string &format_string)
{
auto not_in = format_string.find_first_not_of("/-:, mMyYdDhHsSAP");
return not_in == std::string::npos;
}
bool is_valid_color(const std::string &color)
{
static const std::vector<std::string> *colors =
new std::vector<std::string>(
{
"Black",
"Green",
"White",
"Blue",
"Magenta",
"Yellow",
"Cyan",
"Red"
});
auto compare_color = [&](const std::string &other) {
if (color.size() != other.size()) return false;
for (std::size_t i = 0; i < color.size(); i++)
{
if (std::toupper(color[i]) != std::toupper(other[i]))
{
return false;
}
}
return true;
};
return std::find_if(colors->begin(), colors->end(), compare_color) != colors->end();
}
bool parse_condition(const std::string &string, section &s)
{
s.has_condition = false;
s.condition = condition_type::invalid;
s.condition_value.clear();
if (string[0] == '<')
{
s.has_condition = true;
if (string[1] == '=')
{
s.condition = condition_type::less_or_equal;
s.condition_value = string.substr(2);
}
else
{
s.condition = condition_type::less_than;
s.condition_value = string.substr(1);
}
}
if (string[0] == '>')
{
s.has_condition = true;
if (string[1] == '=')
{
s.condition = condition_type::greater_or_equal;
s.condition_value = string.substr(2);
}
else
{
s.condition = condition_type::greater_than;
s.condition_value = string.substr(1);
}
}
else if (string[0] == '=')
{
s.has_condition = true;
s.condition = condition_type::equal;
s.condition_value = string.substr(1);
}
return s.has_condition;
}
bool is_hex(char c)
{
return (c >= 'A' && c <= 'F') || (c >= '0' && c <= '9');
}
const std::unordered_map<int, std::string> known_locales()
{
const std::unordered_map<int, std::string> *all =
new std::unordered_map<int, std::string>(
{
{ 0x401, "Arabic - Saudi Arabia" },
{ 0x402, "Bulgarian" },
{ 0x403, "Catalan" },
{ 0x404, "Chinese - Taiwan" },
{ 0x405, "Czech" },
{ 0x406, "Danish" },
{ 0x407, "German - Germany" },
{ 0x408, "Greek" },
{ 0x409, "English - United States" },
{ 0x410, "Italian - Italy" },
{ 0x411, "Japanese" },
{ 0x412, "Korean" },
{ 0x413, "Dutch - Netherlands" },
{ 0x414, "Norwegian - Bokml" },
{ 0x415, "Polish" },
{ 0x416, "Portuguese - Brazil" },
{ 0x417, "Raeto-Romance" },
{ 0x418, "Romanian - Romania" },
{ 0x419, "Russian" },
{ 0x420, "Urdu" },
{ 0x421, "Indonesian" },
{ 0x422, "Ukrainian" },
{ 0x423, "Belarusian" },
{ 0x424, "Slovenian" },
{ 0x425, "Estonian" },
{ 0x426, "Latvian" },
{ 0x427, "Lithuanian" },
{ 0x428, "Tajik" },
{ 0x429, "Farsi - Persian" },
{ 0x430, "Sesotho (Sutu)" },
{ 0x431, "Tsonga" },
{ 0x432, "Setsuana" },
{ 0x433, "Venda" },
{ 0x434, "Xhosa" },
{ 0x435, "Zulu" },
{ 0x436, "Afrikaans" },
{ 0x437, "Georgian" },
{ 0x438, "Faroese" },
{ 0x439, "Hindi" },
{ 0x440, "Kyrgyz - Cyrillic" },
{ 0x441, "Swahili" },
{ 0x442, "Turkmen" },
{ 0x443, "Uzbek - Latin" },
{ 0x444, "Tatar" },
{ 0x445, "Bengali - India" },
{ 0x446, "Punjabi" },
{ 0x447, "Gujarati" },
{ 0x448, "Oriya" },
{ 0x449, "Tamil" },
{ 0x450, "Mongolian" },
{ 0x451, "Tibetan" },
{ 0x452, "Welsh" },
{ 0x453, "Khmer" },
{ 0x454, "Lao" },
{ 0x455, "Burmese" },
{ 0x456, "Galician" },
{ 0x457, "Konkani" },
{ 0x458, "Manipuri" },
{ 0x459, "Sindhi" },
{ 0x460, "Kashmiri" },
{ 0x461, "Nepali" },
{ 0x462, "Frisian - Netherlands" },
{ 0x464, "Filipino" },
{ 0x465, "Divehi; Dhivehi; Maldivian" },
{ 0x466, "Edo" },
{ 0x470, "Igbo - Nigeria" },
{ 0x474, "Guarani - Paraguay" },
{ 0x476, "Latin" },
{ 0x477, "Somali" },
{ 0x481, "Maori" },
{ 0x801, "Arabic - Iraq" },
{ 0x804, "Chinese - China" },
{ 0x807, "German - Switzerland" },
{ 0x809, "English - Great Britain" },
{ 0x810, "Italian - Switzerland" },
{ 0x813, "Dutch - Belgium" },
{ 0x814, "Norwegian - Nynorsk" },
{ 0x816, "Portuguese - Portugal" },
{ 0x818, "Romanian - Moldova" },
{ 0x819, "Russian - Moldova" },
{ 0x843, "Uzbek - Cyrillic" },
{ 0x845, "Bengali - Bangladesh" },
{ 0x850, "Mongolian" },
{ 0x1001, "Arabic - Libya" },
{ 0x1004, "Chinese - Singapore" },
{ 0x1007, "German - Luxembourg" },
{ 0x1009, "English - Canada" },
{ 0x1401, "Arabic - Algeria" },
{ 0x1404, "Chinese - Macau SAR" },
{ 0x1407, "German - Liechtenstein" },
{ 0x1409, "English - New Zealand" },
{ 0x1801, "Arabic - Morocco" },
{ 0x1809, "English - Ireland" },
{ 0x2001, "Arabic - Oman" },
{ 0x2009, "English - Jamaica" },
{ 0x2401, "Arabic - Yemen" },
{ 0x2409, "English - Caribbean" },
{ 0x2801, "Arabic - Syria" },
{ 0x2809, "English - Belize" },
{ 0x3001, "Arabic - Lebanon" },
{ 0x3009, "English - Zimbabwe" },
{ 0x3401, "Arabic - Kuwait" },
{ 0x3409, "English - Phillippines" },
{ 0x3801, "Arabic - United Arab Emirates" },
{ 0x4001, "Arabic - Qatar" }
});
return *all;
}
bool is_valid_locale(const std::string &locale_string)
{
auto hyphen_index = locale_string.find('-');
if (hyphen_index == std::string::npos)
{
return false;
}
std::string country = locale_string.substr(hyphen_index + 1);
if (country.empty())
{
return false;
}
for (auto c : country)
{
if (!is_hex(static_cast<char>(std::toupper(c))))
{
return false;
}
}
auto index = std::stoi(country, 0, 16);
auto known_locales_ = known_locales();
if (known_locales_.find(index) == known_locales_.end())
{
return false;
}
std::string beginning = locale_string.substr(0, locale_string.find('-'));
if (beginning.empty() || beginning[0] != '$')
{
return false;
}
if (beginning.size() == 1)
{
return true;
}
beginning = beginning.substr(1);
return true;
}
section parse_section(const std::string &section_string)
{
if (section_string.empty())
{
throw std::runtime_error("empty format");
}
section s;
std::string format_part;
std::string bracket_part;
std::vector<std::string> bracket_parts;
bool in_quotes = false;
bool in_brackets = false;
const std::vector<std::string> bracket_times = { "h", "hh", "m", "mm", "s", "ss" };
for (std::size_t i = 0; i < section_string.size(); i++)
{
if (!in_quotes && section_string[i] == '"')
{
format_part.push_back(section_string[i]);
in_quotes = true;
}
else if (in_quotes && section_string[i] == '"')
{
format_part.push_back(section_string[i]);
if (i < section_string.size() - 1 && section_string[i + 1] != '"')
{
in_quotes = false;
}
}
else if (!in_brackets && section_string[i] == '[')
{
in_brackets = true;
for (auto bracket_time : bracket_times)
{
if (i < section_string.size() - bracket_time.size() &&
section_string.substr(i + 1, bracket_time.size()) == bracket_time)
{
in_brackets = false;
break;
}
}
}
else if (in_brackets)
{
if (section_string[i] == ']')
{
in_brackets = false;
if (is_valid_color(bracket_part))
{
if (!s.has_color)
{
s.color = bracket_part;
s.has_color = true;
}
else
{
throw std::runtime_error("two colors");
}
}
else if (is_valid_locale(bracket_part))
{
if (!s.has_locale)
{
s.locale = bracket_part;
s.has_locale = true;
}
else
{
throw std::runtime_error("two locales");
}
}
else if (s.has_condition || !parse_condition(bracket_part, s))
{
throw std::runtime_error("invalid bracket format");
}
bracket_part.clear();
}
else
{
bracket_part.push_back(section_string[i]);
}
}
else
{
format_part.push_back(section_string[i]);
}
}
s.value = format_part;
s.has_value = true;
return s;
}
format_sections parse_format_sections(const std::string &combined)
{
format_sections result = {};
auto split = split_string(combined, ';');
result.first = parse_section(split[0]);
if (!result.first.has_condition)
{
result.second = result.first;
result.third = result.first;
}
if (split.size() > 1)
{
result.second = parse_section(split[1]);
}
if (split.size() > 2)
{
if (result.first.has_condition && !result.second.has_condition)
{
throw std::runtime_error("first two sections should have conditions");
}
result.third = parse_section(split[2]);
if (result.third.has_condition)
{
throw std::runtime_error("third section shouldn't have a condition");
}
}
if (split.size() > 3)
{
if (result.first.has_condition)
{
throw std::runtime_error("too many parts");
}
result.fourth = parse_section(split[3]);
}
if (split.size() > 4)
{
throw std::runtime_error("too many parts");
}
return result;
}
std::string format_section(long double number, const section &format, xlnt::calendar base_date)
{
const std::string unquoted = "$+(:^'{<=-/)!&~}> ";
std::string format_temp = format.value;
std::string result;
if (is_date_format(format.value))
{
auto lower_string = [](const std::string &s) {
std::string lower;
lower.resize(s.size());
for (std::size_t i = 0; i < s.size(); i++)
lower[i] = static_cast<char>(std::tolower(s[i]));
return lower;
};
auto value = format.value;
bool twelve_hour = false;
if (format.value.size() > 5 && lower_string(value).substr(format.value.size() - 5) == "am/pm")
{
twelve_hour = true;
}
const std::string date_unquoted = ",-/: ";
const std::vector<std::string> dates = { "m", "mm", "mmm", "mmmmm", "mmmmmm", "d", "dd", "ddd", "dddd", "yy",
"yyyy", "h", "[h]", "hh", "m", "[m]", "mm", "s", "[s]", "ss" };
const std::vector<std::string> MonthNames = { "January", "February", "March",
"April", "May", "June", "July", "August", "September", "October", "November", "December" };
auto split = split_string_any(format.value, date_unquoted);
std::string::size_type index = 0, prev = 0;
auto d = xlnt::datetime::from_number(number, base_date);
bool processed_month = false;
for (auto part : split)
{
while (format.value.substr(index, part.size()) != part)
{
index++;
}
part = lower_string(part);
auto between = format.value.substr(prev, index - prev);
if (between == "/" && part == "pm")
{
index += part.size();
prev = index;
continue;
}
result.append(between);
if (part == "m" && !processed_month)
{
result.append(std::to_string(d.month));
processed_month = true;
}
else if (part == "mm" && !processed_month)
{
if (d.month < 10)
{
result.append("0");
}
result.append(std::to_string(d.month));
processed_month = true;
}
else if (part == "mmm" && !processed_month)
{
result.append(MonthNames.at(static_cast<std::size_t>(d.month - 1)).substr(0, 3));
processed_month = true;
}
else if (part == "mmmm" && !processed_month)
{
result.append(MonthNames.at(static_cast<std::size_t>(d.month - 1)));
processed_month = true;
}
else if (part == "d")
{
result.append(std::to_string(d.day));
}
else if (part == "dd")
{
if (d.day < 10)
{
result.append("0");
}
result.append(std::to_string(d.day));
}
else if (part == "yy")
{
result.append(std::to_string(d.year % 1000));
}
else if (part == "yyyy")
{
result.append(std::to_string(d.year));
}
else if (part == "h")
{
if (twelve_hour)
{
result.append(std::to_string(d.hour % 12));
}
else
{
result.append(std::to_string(d.hour));
}
processed_month = true;
}
else if (part == "hh")
{
if (twelve_hour)
{
if (d.hour % 12 < 10)
{
result.append("0");
}
result.append(std::to_string(d.hour % 12));
}
else
{
if (d.hour < 10)
{
result.append("0");
}
result.append(std::to_string(d.hour));
}
processed_month = true;
}
else if (part == "m")
{
result.append(std::to_string(d.minute));
}
else if (part == "mm")
{
if (d.minute < 10)
{
result.append("0");
}
result.append(std::to_string(d.minute));
}
else if (part == "s")
{
result.append(std::to_string(d.second));
}
else if (part == "ss")
{
if (d.second < 10)
{
result.append("0");
}
result.append(std::to_string(d.second));
}
else if (part == "am")
{
if (d.hour < 12)
{
result.append("AM");
}
else
{
result.append("PM");
}
}
index += part.size();
prev = index;
}
if (index < format.value.size())
{
result.append(format.value.substr(index));
}
}
else if (format.value.find_first_of("General") != std::string::npos || format.value == "0")
{
std::string before_text, end_text;
auto open_quote = format.value.find('"');
if (open_quote != std::string::npos)
{
auto close_quote = format.value.find('"', open_quote + 1);
auto quoted_text = format.value.substr(open_quote, close_quote - open_quote + 1);
if (open_quote == 0)
{
before_text = quoted_text.substr(1, quoted_text.size() - 2);
}
else
{
end_text = quoted_text.substr(1, quoted_text.size() - 2);
}
}
if (number < 0)
{
before_text = std::string("-") + before_text;
}
result = before_text;
if (number == static_cast<long long int>(number))
{
result.append(std::to_string(static_cast<long long int>(std::abs(number))));
}
else
{
auto number_string = std::to_string(std::abs(number));
while (number_string.find('.') != std::string::npos && number_string.back() == '0' && number_string.find('.') < number_string.size() - 1)
{
number_string.erase(number_string.end() - 1);
}
result.append(number_string);
}
result.append(end_text);
}
else if (format.value.find("#,##0.00") != std::string::npos)
{
auto index = format.value.find("#,##0.00");
auto before_text = format.value.substr(0, index);
auto after_text = format.value.substr(index + 8);
bool minus_first = before_text.substr(0, 1) == "-";
if (minus_first)
{
before_text = before_text.substr(1);
}
if (format.has_locale && format.locale == "$$-1009")
{
before_text = std::string(minus_first ? "-" : "") + "CA$" + before_text;
}
else if (format.has_locale && format.locale == "$€-407")
{
before_text = std::string(minus_first ? "-" : "") + "" + before_text;
}
result = before_text + std::to_string(number < 0 ? -number : number) + after_text;
auto decimal_pos = result.find('.');
if (decimal_pos != std::string::npos)
{
result[decimal_pos] = ',';
decimal_pos += 3;
while (decimal_pos < result.size())
{
result.pop_back();
}
}
}
return result;
}
std::string format_section(const std::string &text, const section &format)
{
auto arobase_index = format.value.find('@');
std::string first_part, middle_part, last_part;
if (arobase_index != std::string::npos)
{
first_part = format.value.substr(0, arobase_index);
middle_part = text;
last_part = format.value.substr(arobase_index + 1);
}
else
{
first_part = format.value;
}
auto unquote = [](std::string &s) {
if (!s.empty())
{
if (s.front() != '"' || s.back() != '"') return false;
s = s.substr(1, s.size() - 2);
}
return true;
};
if (!unquote(first_part) || !unquote(last_part))
{
throw std::runtime_error(std::string("additional text must be enclosed in quotes: ") + format.value);
}
return first_part + middle_part + last_part;
}
std::string format_number(long double number, const std::string &format, xlnt::calendar base_date)
{
auto sections = parse_format_sections(format);
if (sections.first.has_condition)
{
auto right_side = std::stod(sections.first.condition_value);
if ((sections.first.condition == condition_type::equal && number == right_side) ||
(sections.first.condition == condition_type::greater_or_equal && number >= right_side) ||
(sections.first.condition == condition_type::greater_than && number > right_side) ||
(sections.first.condition == condition_type::less_or_equal && number <= right_side) ||
(sections.first.condition == condition_type::less_than && number < right_side))
{
return format_section(number, sections.first, base_date);
}
right_side = std::stod(sections.second.condition_value);
if ((sections.second.condition == condition_type::equal && number == right_side) ||
(sections.second.condition == condition_type::greater_or_equal && number >= right_side) ||
(sections.second.condition == condition_type::greater_than && number > right_side) ||
(sections.second.condition == condition_type::less_or_equal && number <= right_side) ||
(sections.second.condition == condition_type::less_than && number < right_side))
{
return format_section(number, sections.second, base_date);
}
}
else
{
if (number > 0)
{
return format_section(number, sections.first, base_date);
}
else if (number < 0)
{
return format_section(number, sections.second, base_date);
}
}
// number == 0 or default condition
return format_section(number, sections.third, base_date);
}
std::string format_text(const std::string &text, const std::string &format)
{
if (format == "General" || format == "@") return text;
auto sections = parse_format_sections(format);
return format_section(text, sections.fourth);
}
} // namespace
namespace xlnt {
const number_format number_format::general()
{
static const number_format *format = new number_format(builtin_formats().at(0), 0);
return *format;
}
const number_format number_format::text()
{
static const number_format *format = new number_format(builtin_formats().at(49), 49);
return *format;
}
const number_format number_format::number()
{
static const number_format *format = new number_format(builtin_formats().at(1), 1);
return *format;
}
const number_format number_format::number_00()
{
static const number_format *format = new number_format(builtin_formats().at(2), 2);
return *format;
}
const number_format number_format::number_comma_separated1()
{
static const number_format *format = new number_format(builtin_formats().at(4), 4);
return *format;
}
const number_format number_format::percentage()
{
static const number_format *format = new number_format(builtin_formats().at(9), 9);
return *format;
}
const number_format number_format::percentage_00()
{
static const number_format *format = new number_format(builtin_formats().at(10), 10);
return *format;
}
const number_format number_format::date_yyyymmdd2()
{
static const number_format *format = new number_format("yyyy-mm-dd");
return *format;
}
const number_format number_format::date_yyyymmdd()
{
static const number_format *format = new number_format("yy-mm-dd");
return *format;
}
const number_format number_format::date_ddmmyyyy()
{
static const number_format *format = new number_format("dd/mm/yy");
return *format;
}
const number_format number_format::date_dmyslash()
{
static const number_format *format = new number_format("d/m/y");
return *format;
}
const number_format number_format::date_dmyminus()
{
static const number_format *format = new number_format("d-m-y");
return *format;
}
const number_format number_format::date_dmminus()
{
static const number_format *format = new number_format("d-m");
return *format;
}
const number_format number_format::date_myminus()
{
static const number_format *format = new number_format("m-y");
return *format;
}
const number_format number_format::date_xlsx14()
{
static const number_format *format = new number_format(builtin_formats().at(14), 14);
return *format;
}
const number_format number_format::date_xlsx15()
{
static const number_format *format = new number_format(builtin_formats().at(15), 15);
return *format;
}
const number_format number_format::date_xlsx16()
{
static const number_format *format = new number_format(builtin_formats().at(16), 16);
return *format;
}
const number_format number_format::date_xlsx17()
{
static const number_format *format = new number_format(builtin_formats().at(17), 17);
return *format;
}
const number_format number_format::date_xlsx22()
{
static const number_format *format = new number_format(builtin_formats().at(22), 22);
return *format;
}
const number_format number_format::date_datetime()
{
static const number_format *format = new number_format("yyyy-mm-dd h:mm:ss");
return *format;
}
const number_format number_format::date_time1()
{
static const number_format *format = new number_format(builtin_formats().at(18), 18);
return *format;
}
const number_format number_format::date_time2()
{
static const number_format *format = new number_format(builtin_formats().at(19), 19);
return *format;
}
const number_format number_format::date_time3()
{
static const number_format *format = new number_format(builtin_formats().at(20), 20);
return *format;
}
const number_format number_format::date_time4()
{
static const number_format *format = new number_format(builtin_formats().at(21), 21);
return *format;
}
const number_format number_format::date_time5()
{
static const number_format *format = new number_format(builtin_formats().at(45), 45);
return *format;
}
const number_format number_format::date_time6()
{
static const number_format *format = new number_format(builtin_formats().at(21), 21);
return *format;
}
const number_format number_format::date_time7()
{
static const number_format *format = new number_format("i:s.S");
return *format;
}
const number_format number_format::date_time8()
{
static const number_format *format = new number_format("h:mm:ss@");
return *format;
}
const number_format number_format::date_timedelta()
{
static const number_format *format = new number_format("[hh]:mm:ss");
return *format;
}
const number_format number_format::date_yyyymmddslash()
{
static const number_format *format = new number_format("yy/mm/dd@");
return *format;
}
const number_format number_format::currency_usd_simple()
{
static const number_format *format = new number_format("\"$\"#,##0.00_-");
return *format;
}
const number_format number_format::currency_usd()
{
static const number_format *format = new number_format("$#,##0_-");
return *format;
}
const number_format number_format::currency_eur_simple()
{
static const number_format *format = new number_format("[$EUR ]#,##0.00_-");
return *format;
}
number_format::number_format() : number_format(general())
{
}
number_format::number_format(std::size_t id) : number_format(from_builtin_id(id))
{
}
number_format::number_format(const std::string &format_string) : id_set_(false), id_(0)
{
set_format_string(format_string);
}
number_format::number_format(const std::string &format_string, std::size_t id) : id_set_(false), id_(0)
{
set_format_string(format_string, id);
}
number_format number_format::from_builtin_id(std::size_t builtin_id)
{
if (builtin_formats().find(builtin_id) == builtin_formats().end())
{
throw std::runtime_error("unknown id: " + std::to_string(builtin_id));
}
auto format_string = builtin_formats().at(builtin_id);
return number_format(format_string, builtin_id);
}
std::string number_format::get_format_string() const
{
return format_string_;
}
std::string number_format::to_hash_string() const
{
std::string hash_string("number_format");
hash_string.append(format_string_);
hash_string.append("|||");
hash_string.append(std::to_string(id_));
return hash_string;
}
void number_format::set_format_string(const std::string &format_string)
{
format_string_ = format_string;
id_ = 0;
id_set_ = false;
for (const auto &pair : builtin_formats())
{
if (pair.second == format_string)
{
id_ = pair.first;
id_set_ = true;
break;
}
}
}
void number_format::set_format_string(const std::string &format_string, std::size_t id)
{
format_string_ = format_string;
id_ = id;
id_set_ = true;
}
bool number_format::has_id() const
{
return id_set_;
}
void number_format::set_id(std::size_t id)
{
id_ = id;
id_set_ = true;
}
std::size_t number_format::get_id() const
{
if(!id_set_)
{
throw std::runtime_error("number format doesn't have an id");
}
return id_;
}
bool number_format::is_date_format() const
{
if (format_string_ != "General")
{
try
{
auto sections = parse_format_sections(format_string_);
return ::is_date_format(sections.first.value);
}
catch (std::exception)
{
return false;
}
}
return false;
}
std::string number_format::format(const std::string &text) const
{
return format_text(text, format_string_);
}
std::string number_format::format(long double number, calendar base_date) const
{
return format_number(number, format_string_, base_date);
}
} // namespace xlnt