zhangyiss/toml11
1
0
Fork 0
mirror of https://github.com/ToruNiina/toml11.git synced 2025-12-16 03:08:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix typo

Browse Source
This commit is contained in:
ToruNiina
2017-05-17 10:55:22 +09:00
parent 5e6d699452
commit 9e9a5a7253
6 changed files with 260 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
tests/test_acceptor.cpp
View File

@@ -102,8 +102,8 @@ BOOST_AUTO_TEST_CASE(test_basic_inline_string)
BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin(), invalid_escape.cend()) == invalid_escape.cbegin()); BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin(), invalid_escape.cend()) == invalid_escape.cbegin());
} }
{ {
const std::string invalid_charactor("\"foo\10bar\""); const std::string invalid_character("\"foo\10bar\"");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin()); BOOST_CHECK(is_valid::invoke(invalid_character.cbegin(), invalid_character.cend()) == invalid_character.cbegin());
} }
{ {
const std::string multi("\"\"\"multiline\"\"\""); const std::string multi("\"\"\"multiline\"\"\"");
@@ -144,8 +144,8 @@ BOOST_AUTO_TEST_CASE(test_basic_multiline_string)
BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin(), invalid_escape.cend()) == invalid_escape.cbegin()); BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin(), invalid_escape.cend()) == invalid_escape.cbegin());
} }
{ {
const std::string invalid_charactor("\"\"\"foo\10bar\"\"\""); const std::string invalid_character("\"\"\"foo\10bar\"\"\"");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin()); BOOST_CHECK(is_valid::invoke(invalid_character.cbegin(), invalid_character.cend()) == invalid_character.cbegin());
} }
{ {
const std::string single("\"singleline\""); const std::string single("\"singleline\"");
@@ -178,8 +178,8 @@ BOOST_AUTO_TEST_CASE(test_literal_inline_string)
BOOST_CHECK(is_valid::invoke(newline.cbegin(), newline.cend()) == newline.cbegin()); BOOST_CHECK(is_valid::invoke(newline.cbegin(), newline.cend()) == newline.cbegin());
} }
{ {
const std::string invalid_charactor("'foo\10bar'"); const std::string invalid_character("'foo\10bar'");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin()); BOOST_CHECK(is_valid::invoke(invalid_character.cbegin(), invalid_character.cend()) == invalid_character.cbegin());
} }
{ {
const std::string multi("'''multiline'''"); const std::string multi("'''multiline'''");
@@ -212,8 +212,8 @@ BOOST_AUTO_TEST_CASE(test_literal_multiline_string)
} }
{ {
const std::string invalid_charactor("'''foo\10bar'''"); const std::string invalid_character("'''foo\10bar'''");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin()); BOOST_CHECK(is_valid::invoke(invalid_character.cbegin(), invalid_character.cend()) == invalid_character.cbegin());
} }
{ {
const std::string single("'singleline'"); const std::string single("'singleline'");

36
tests/test_parser.cpp
View File

@@ -14,7 +14,7 @@
BOOST_AUTO_TEST_CASE(test_parse_basic_inline_string) BOOST_AUTO_TEST_CASE(test_parse_basic_inline_string)
{ {
typedef toml::parse_basic_inline_string parser; typedef toml::parse_basic_inline_string parser;
typedef toml::is_basic_inline_string<toml::charactor> acceptor; typedef toml::is_basic_inline_string<toml::character> acceptor;
{ {
const std::string source("\"simple\""); const std::string source("\"simple\"");
const std::string expected("simple"); const std::string expected("simple");
@@ -42,7 +42,7 @@ BOOST_AUTO_TEST_CASE(test_parse_basic_inline_string)
BOOST_AUTO_TEST_CASE(test_parse_basic_multiline_string) BOOST_AUTO_TEST_CASE(test_parse_basic_multiline_string)
{ {
typedef toml::parse_basic_multiline_string parser; typedef toml::parse_basic_multiline_string parser;
typedef toml::is_basic_multiline_string<toml::charactor> acceptor; typedef toml::is_basic_multiline_string<toml::character> acceptor;
{ {
//XXX ifdef windows platform //XXX ifdef windows platform
const std::string source("\"\"\"\nRoses are red\nViolets are blue\"\"\""); const std::string source("\"\"\"\nRoses are red\nViolets are blue\"\"\"");
@@ -79,7 +79,7 @@ BOOST_AUTO_TEST_CASE(test_parse_basic_multiline_string)
BOOST_AUTO_TEST_CASE(test_parse_literal_inline_string) BOOST_AUTO_TEST_CASE(test_parse_literal_inline_string)
{ {
typedef toml::parse_literal_inline_string parser; typedef toml::parse_literal_inline_string parser;
typedef toml::is_literal_inline_string<toml::charactor> acceptor; typedef toml::is_literal_inline_string<toml::character> acceptor;
{ {
const std::string source("'C:\\Users\\nodejs\\templates'"); const std::string source("'C:\\Users\\nodejs\\templates'");
const std::string expected("C:\\Users\\nodejs\\templates"); const std::string expected("C:\\Users\\nodejs\\templates");
@@ -123,7 +123,7 @@ BOOST_AUTO_TEST_CASE(test_parse_literal_inline_string)
BOOST_AUTO_TEST_CASE(test_parse_literal_multiline_string) BOOST_AUTO_TEST_CASE(test_parse_literal_multiline_string)
{ {
typedef toml::parse_literal_multiline_string parser; typedef toml::parse_literal_multiline_string parser;
typedef toml::is_literal_multiline_string<toml::charactor> acceptor; typedef toml::is_literal_multiline_string<toml::character> acceptor;
{ {
const std::string source("'''I [dw]on't need \\d{2} apples'''"); const std::string source("'''I [dw]on't need \\d{2} apples'''");
const std::string expected("I [dw]on't need \\d{2} apples"); const std::string expected("I [dw]on't need \\d{2} apples");
@@ -151,7 +151,7 @@ BOOST_AUTO_TEST_CASE(test_parse_literal_multiline_string)
BOOST_AUTO_TEST_CASE(test_parse_string) BOOST_AUTO_TEST_CASE(test_parse_string)
{ {
typedef toml::parse_string parser; typedef toml::parse_string parser;
typedef toml::is_string<toml::charactor> acceptor; typedef toml::is_string<toml::character> acceptor;
{ {
const std::string source("\"string\""); const std::string source("\"string\"");
const std::string expected("string"); const std::string expected("string");
@@ -195,7 +195,7 @@ BOOST_AUTO_TEST_CASE(test_parse_string)
BOOST_AUTO_TEST_CASE(test_integer) BOOST_AUTO_TEST_CASE(test_integer)
{ {
typedef toml::parse_integer parser; typedef toml::parse_integer parser;
typedef toml::is_integer<toml::charactor> acceptor; typedef toml::is_integer<toml::character> acceptor;
{ {
const std::string source("42"); const std::string source("42");
const toml::Integer expected(42); const toml::Integer expected(42);
@@ -239,7 +239,7 @@ BOOST_AUTO_TEST_CASE(test_integer)
BOOST_AUTO_TEST_CASE(test_float) BOOST_AUTO_TEST_CASE(test_float)
{ {
typedef toml::parse_float parser; typedef toml::parse_float parser;
typedef toml::is_float<toml::charactor> acceptor; typedef toml::is_float<toml::character> acceptor;
{ {
const std::string source("42.0"); const std::string source("42.0");
const toml::Float expected(42.0); const toml::Float expected(42.0);
@@ -305,7 +305,7 @@ BOOST_AUTO_TEST_CASE(test_float)
BOOST_AUTO_TEST_CASE(test_parse_boolean) BOOST_AUTO_TEST_CASE(test_parse_boolean)
{ {
typedef toml::parse_boolean parser; typedef toml::parse_boolean parser;
typedef toml::is_boolean<toml::charactor> acceptor; typedef toml::is_boolean<toml::character> acceptor;
{ {
const std::string source("true"); const std::string source("true");
const toml::Boolean expected(true); const toml::Boolean expected(true);
@@ -335,7 +335,7 @@ BOOST_AUTO_TEST_CASE(test_parse_boolean)
BOOST_AUTO_TEST_CASE(test_parse_local_time) BOOST_AUTO_TEST_CASE(test_parse_local_time)
{ {
typedef toml::parse_local_time parser; typedef toml::parse_local_time parser;
typedef toml::is_local_time<toml::charactor> acceptor; typedef toml::is_local_time<toml::character> acceptor;
{ {
const std::string source("12:34:56"); const std::string source("12:34:56");
const toml::Datetime expected(12, 34, 56, 0, 0); const toml::Datetime expected(12, 34, 56, 0, 0);
@@ -371,7 +371,7 @@ BOOST_AUTO_TEST_CASE(test_parse_local_time)
BOOST_AUTO_TEST_CASE(test_parse_local_date) BOOST_AUTO_TEST_CASE(test_parse_local_date)
{ {
typedef toml::parse_local_date parser; typedef toml::parse_local_date parser;
typedef toml::is_local_date<toml::charactor> acceptor; typedef toml::is_local_date<toml::character> acceptor;
{ {
const std::string source("1979-09-27"); const std::string source("1979-09-27");
const toml::Datetime expected(1979, 9, 27); const toml::Datetime expected(1979, 9, 27);
@@ -391,7 +391,7 @@ BOOST_AUTO_TEST_CASE(test_parse_local_date)
BOOST_AUTO_TEST_CASE(test_parse_local_date_time) BOOST_AUTO_TEST_CASE(test_parse_local_date_time)
{ {
typedef toml::parse_local_date_time parser; typedef toml::parse_local_date_time parser;
typedef toml::is_local_date_time<toml::charactor> acceptor; typedef toml::is_local_date_time<toml::character> acceptor;
{ {
const std::string source("1979-09-27T12:34:56"); const std::string source("1979-09-27T12:34:56");
const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0);
@@ -419,7 +419,7 @@ BOOST_AUTO_TEST_CASE(test_parse_local_date_time)
BOOST_AUTO_TEST_CASE(test_parse_offset_date_time) BOOST_AUTO_TEST_CASE(test_parse_offset_date_time)
{ {
typedef toml::parse_offset_date_time parser; typedef toml::parse_offset_date_time parser;
typedef toml::is_offset_date_time<toml::charactor> acceptor; typedef toml::is_offset_date_time<toml::character> acceptor;
{ {
const std::string source("1979-09-27T12:34:56Z"); const std::string source("1979-09-27T12:34:56Z");
const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0);
@@ -481,7 +481,7 @@ BOOST_AUTO_TEST_CASE(test_parse_offset_date_time)
BOOST_AUTO_TEST_CASE(test_parse_datetime) BOOST_AUTO_TEST_CASE(test_parse_datetime)
{ {
typedef toml::parse_datetime parser; typedef toml::parse_datetime parser;
typedef toml::is_datetime<toml::charactor> acceptor; typedef toml::is_datetime<toml::character> acceptor;
{ {
const std::string source("1979-09-27T12:34:56Z"); const std::string source("1979-09-27T12:34:56Z");
const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0);
@@ -525,8 +525,8 @@ BOOST_AUTO_TEST_CASE(test_parse_datetime)
BOOST_AUTO_TEST_CASE(test_parse_array) BOOST_AUTO_TEST_CASE(test_parse_array)
{ {
typedef toml::parse_array<toml::charactor> parser; typedef toml::parse_array<toml::character> parser;
typedef toml::is_array<toml::charactor> acceptor; typedef toml::is_array<toml::character> acceptor;
{ {
const std::string source("[1,2,3]"); const std::string source("[1,2,3]");
const toml::Array expected{1, 2, 3}; const toml::Array expected{1, 2, 3};
@@ -630,8 +630,8 @@ BOOST_AUTO_TEST_CASE(test_parse_array)
BOOST_AUTO_TEST_CASE(test_parse_inline_table) BOOST_AUTO_TEST_CASE(test_parse_inline_table)
{ {
typedef toml::parse_inline_table<toml::charactor> parser; typedef toml::parse_inline_table<toml::character> parser;
typedef toml::is_inline_table<toml::charactor> acceptor; typedef toml::is_inline_table<toml::character> acceptor;
{ {
const std::string source("{foo=1,bar=2.0,baz='str'}"); const std::string source("{foo=1,bar=2.0,baz='str'}");
const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}}; const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}};
@@ -679,7 +679,7 @@ BOOST_AUTO_TEST_CASE(test_parse_inline_table)
BOOST_AUTO_TEST_CASE(test_parse_barekey) BOOST_AUTO_TEST_CASE(test_parse_barekey)
{ {
typedef toml::parse_barekey parser; typedef toml::parse_barekey parser;
typedef toml::is_barekey<toml::charactor> acceptor; typedef toml::is_barekey<toml::character> acceptor;
{ {
const std::string source("hoge"); const std::string source("hoge");
const toml::key expected("hoge"); const toml::key expected("hoge");

162
toml/acceptor.hpp
View File

@@ -9,7 +9,7 @@ namespace toml
{ {
template<typename charT, charT c> template<typename charT, charT c>
struct is_charactor struct is_character
{ {
typedef charT value_type; typedef charT value_type;
constexpr static value_type target = c; constexpr static value_type target = c;
@@ -240,9 +240,9 @@ struct is_not_but
}; };
template<typename charT> template<typename charT>
using is_space = is_charactor<charT, ' '>; using is_space = is_character<charT, ' '>;
template<typename charT> template<typename charT>
using is_tab = is_charactor<charT, '\t'>; using is_tab = is_character<charT, '\t'>;
template<typename charT> template<typename charT>
using is_number = is_in_range<charT, '0', '9'>; using is_number = is_in_range<charT, '0', '9'>;
template<typename charT> template<typename charT>
@@ -261,17 +261,17 @@ using is_any_num_of_ws =
is_ignorable<is_repeat_of<is_whitespace<charT>, repeat_infinite()>>; is_ignorable<is_repeat_of<is_whitespace<charT>, repeat_infinite()>>;
template<typename charT> template<typename charT>
using is_newline = is_one_of<is_charactor<charT, '\n'>, using is_newline = is_one_of<is_character<charT, '\n'>,
is_chain_of<is_charactor<charT, '\r'>, is_charactor<charT, '\n'>>>; is_chain_of<is_character<charT, '\r'>, is_character<charT, '\n'>>>;
template<typename charT> template<typename charT>
using is_barekey_component = is_one_of<is_alphabet<charT>, is_number<charT>, using is_barekey_component = is_one_of<is_alphabet<charT>, is_number<charT>,
is_charactor<charT, '_'>, is_charactor<charT, '-'>>; is_character<charT, '_'>, is_character<charT, '-'>>;
template<typename charT> template<typename charT>
using is_barekey = is_repeat_of<is_barekey_component<charT>, repeat_infinite()>; using is_barekey = is_repeat_of<is_barekey_component<charT>, repeat_infinite()>;
template<typename charT> template<typename charT>
using is_comment = using is_comment =
is_chain_of< is_chain_of<
is_charactor<charT, '#'>, is_character<charT, '#'>,
is_repeat_of<is_none_of<is_newline<charT>>, repeat_infinite()>, is_repeat_of<is_none_of<is_newline<charT>>, repeat_infinite()>,
is_newline<charT> is_newline<charT>
>; >;
@@ -279,73 +279,73 @@ using is_comment =
template<typename charT> template<typename charT>
using is_basic_inline_string_component = using is_basic_inline_string_component =
is_one_of< is_one_of<
is_none_of< is_in_range<charT, '\0', '\31'>, is_charactor<charT, '\"'>, is_none_of< is_in_range<charT, '\0', '\31'>, is_character<charT, '\"'>,
is_charactor<charT, '\\'>, is_newline<charT>>, is_character<charT, '\\'>, is_newline<charT>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, '\"'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, '\"'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, '\\'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, '\\'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'b'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'b'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 't'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 't'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'n'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'n'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'f'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'f'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'r'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'r'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'u'>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'u'>,
is_repeat_of<is_hex<charT>, 4>>, is_repeat_of<is_hex<charT>, 4>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'U'>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'U'>,
is_repeat_of<is_hex<charT>, 8>> is_repeat_of<is_hex<charT>, 8>>
>; >;
template<typename charT> template<typename charT>
using is_basic_inline_string = using is_basic_inline_string =
is_not_but< is_not_but<
is_repeat_of<is_charactor<charT, '\"'>, 3>, // not multiline is_repeat_of<is_character<charT, '\"'>, 3>, // not multiline
is_chain_of< is_chain_of<
is_charactor<charT, '\"'>, is_character<charT, '\"'>,
is_ignorable<is_repeat_of<is_basic_inline_string_component<charT>, is_ignorable<is_repeat_of<is_basic_inline_string_component<charT>,
repeat_infinite()>>, repeat_infinite()>>,
is_charactor<charT, '\"'> is_character<charT, '\"'>
> >
>; >;
template<typename charT> template<typename charT>
using is_basic_multiline_string_component = using is_basic_multiline_string_component =
is_one_of< is_one_of<
is_none_of< is_in_range<charT, '\0', '\31'>, is_none_of< is_in_range<charT, '\0', '\31'>,
is_repeat_of<is_charactor<charT, '\"'>, 3>, is_repeat_of<is_character<charT, '\"'>, 3>,
is_charactor<charT, '\\'>>, is_character<charT, '\\'>>,
is_newline<charT>, is_newline<charT>,
is_chain_of<is_charactor<charT, '\\'>, is_newline<charT>>, is_chain_of<is_character<charT, '\\'>, is_newline<charT>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, '\"'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, '\"'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, '\\'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, '\\'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'b'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'b'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 't'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 't'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'n'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'n'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'f'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'f'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'r'>>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'r'>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'u'>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'u'>,
is_repeat_of<is_hex<charT>, 4>>, is_repeat_of<is_hex<charT>, 4>>,
is_chain_of<is_charactor<charT, '\\'>, is_charactor<charT, 'U'>, is_chain_of<is_character<charT, '\\'>, is_character<charT, 'U'>,
is_repeat_of<is_hex<charT>, 8>> is_repeat_of<is_hex<charT>, 8>>
>; >;
template<typename charT> template<typename charT>
using is_basic_multiline_string = using is_basic_multiline_string =
is_chain_of< is_chain_of<
is_repeat_of<is_charactor<charT, '\"'>, 3>, is_repeat_of<is_character<charT, '\"'>, 3>,
is_ignorable<is_repeat_of<is_basic_multiline_string_component<charT>, is_ignorable<is_repeat_of<is_basic_multiline_string_component<charT>,
repeat_infinite()>>, repeat_infinite()>>,
is_repeat_of<is_charactor<charT, '\"'>, 3> is_repeat_of<is_character<charT, '\"'>, 3>
>; >;
template<typename charT> template<typename charT>
using is_literal_inline_string_component = using is_literal_inline_string_component =
is_none_of<is_in_range<charT, '\0', '\31'>, is_charactor<charT, '\''>>; is_none_of<is_in_range<charT, '\0', '\31'>, is_character<charT, '\''>>;
template<typename charT> template<typename charT>
using is_literal_inline_string = using is_literal_inline_string =
is_not_but< is_not_but<
is_repeat_of<is_charactor<charT, '\''>, 3>, is_repeat_of<is_character<charT, '\''>, 3>,
is_chain_of< is_chain_of<
is_charactor<charT, '\''>, is_character<charT, '\''>,
is_ignorable<is_repeat_of<is_literal_inline_string_component<charT>, is_ignorable<is_repeat_of<is_literal_inline_string_component<charT>,
repeat_infinite()>>, repeat_infinite()>>,
is_charactor<charT, '\''> is_character<charT, '\''>
> >
>; >;
@@ -353,17 +353,17 @@ template<typename charT>
using is_literal_multiline_string_component = using is_literal_multiline_string_component =
is_one_of< is_one_of<
is_none_of<is_in_range<charT, '\0', '\31'>, is_none_of<is_in_range<charT, '\0', '\31'>,
is_repeat_of<is_charactor<charT, '\''>, 3>>, is_repeat_of<is_character<charT, '\''>, 3>>,
is_newline<charT> is_newline<charT>
>; >;
template<typename charT> template<typename charT>
using is_literal_multiline_string = using is_literal_multiline_string =
is_chain_of< is_chain_of<
is_repeat_of<is_charactor<charT, '\''>, 3>, is_repeat_of<is_character<charT, '\''>, 3>,
is_ignorable<is_repeat_of<is_literal_multiline_string_component<charT>, is_ignorable<is_repeat_of<is_literal_multiline_string_component<charT>,
repeat_infinite()>>, repeat_infinite()>>,
is_repeat_of<is_charactor<charT, '\''>, 3> is_repeat_of<is_character<charT, '\''>, 3>
>; >;
template<typename charT> template<typename charT>
@@ -377,16 +377,16 @@ using is_string =
template<typename charT> template<typename charT>
using is_sign = is_one_of<is_charactor<charT, '+'>, is_charactor<charT, '-'>>; using is_sign = is_one_of<is_character<charT, '+'>, is_character<charT, '-'>>;
template<typename charT> template<typename charT>
using is_nonzero_number = is_in_range<charT, '1', '9'>; using is_nonzero_number = is_in_range<charT, '1', '9'>;
template<typename charT> template<typename charT>
using is_integer_component = using is_integer_component =
is_not_but< is_not_but<
is_repeat_of<is_charactor<charT, '_'>, 2>, is_repeat_of<is_character<charT, '_'>, 2>,
is_one_of< is_one_of<
is_charactor<charT, '_'>, is_number<charT> is_character<charT, '_'>, is_number<charT>
> >
>; >;
template<typename charT> template<typename charT>
@@ -394,7 +394,7 @@ using is_integer =
is_chain_of< is_chain_of<
is_ignorable<is_sign<charT>>, is_ignorable<is_sign<charT>>,
is_one_of< is_one_of<
is_charactor<charT, '0'>, is_character<charT, '0'>,
is_chain_of< is_chain_of<
is_nonzero_number<charT>, is_nonzero_number<charT>,
is_ignorable<is_repeat_of<is_integer_component<charT>, is_ignorable<is_repeat_of<is_integer_component<charT>,
@@ -407,13 +407,13 @@ using is_integer =
template<typename charT> template<typename charT>
using is_fractional_part = using is_fractional_part =
is_chain_of< is_chain_of<
is_charactor<charT, '.'>, is_character<charT, '.'>,
is_repeat_of<is_integer_component<charT>, repeat_infinite()> is_repeat_of<is_integer_component<charT>, repeat_infinite()>
>; >;
template<typename charT> template<typename charT>
using is_exponent_part = using is_exponent_part =
is_chain_of< is_chain_of<
is_one_of<is_charactor<charT, 'e'>, is_charactor<charT, 'E'>>, is_one_of<is_character<charT, 'e'>, is_character<charT, 'E'>>,
is_integer<charT> is_integer<charT>
>; >;
template<typename charT> template<typename charT>
@@ -438,17 +438,17 @@ template<typename charT>
using is_boolean = using is_boolean =
is_one_of< is_one_of<
is_chain_of< is_chain_of<
is_charactor<charT, 't'>, is_character<charT, 't'>,
is_charactor<charT, 'r'>, is_character<charT, 'r'>,
is_charactor<charT, 'u'>, is_character<charT, 'u'>,
is_charactor<charT, 'e'> is_character<charT, 'e'>
>, >,
is_chain_of< is_chain_of<
is_charactor<charT, 'f'>, is_character<charT, 'f'>,
is_charactor<charT, 'a'>, is_character<charT, 'a'>,
is_charactor<charT, 'l'>, is_character<charT, 'l'>,
is_charactor<charT, 's'>, is_character<charT, 's'>,
is_charactor<charT, 'e'> is_character<charT, 'e'>
> >
>; >;
@@ -456,13 +456,13 @@ template<typename charT>
using is_local_time = using is_local_time =
is_chain_of< is_chain_of<
is_repeat_of<is_number<charT>, 2>, is_repeat_of<is_number<charT>, 2>,
is_charactor<charT, ':'>, is_character<charT, ':'>,
is_repeat_of<is_number<charT>, 2>, is_repeat_of<is_number<charT>, 2>,
is_charactor<charT, ':'>, is_character<charT, ':'>,
is_repeat_of<is_number<charT>, 2>, is_repeat_of<is_number<charT>, 2>,
is_ignorable< is_ignorable<
is_chain_of< is_chain_of<
is_charactor<charT, '.'>, is_character<charT, '.'>,
is_repeat_of<is_number<charT>, repeat_infinite()> is_repeat_of<is_number<charT>, repeat_infinite()>
> >
> >
@@ -472,9 +472,9 @@ template<typename charT>
using is_local_date = using is_local_date =
is_chain_of< is_chain_of<
is_repeat_of<is_number<charT>, 4>, is_repeat_of<is_number<charT>, 4>,
is_charactor<charT, '-'>, is_character<charT, '-'>,
is_repeat_of<is_number<charT>, 2>, is_repeat_of<is_number<charT>, 2>,
is_charactor<charT, '-'>, is_character<charT, '-'>,
is_repeat_of<is_number<charT>, 2> is_repeat_of<is_number<charT>, 2>
>; >;
@@ -482,18 +482,18 @@ template<typename charT>
using is_local_date_time = using is_local_date_time =
is_chain_of< is_chain_of<
is_local_date<charT>, is_local_date<charT>,
is_charactor<charT, 'T'>, is_character<charT, 'T'>,
is_local_time<charT> is_local_time<charT>
>; >;
template<typename charT> template<typename charT>
using is_offset = using is_offset =
is_one_of< is_one_of<
is_charactor<charT, 'Z'>, is_character<charT, 'Z'>,
is_chain_of< is_chain_of<
is_sign<charT>, is_sign<charT>,
is_repeat_of<is_number<charT>, 2>, is_repeat_of<is_number<charT>, 2>,
is_charactor<charT, ':'>, is_character<charT, ':'>,
is_repeat_of<is_number<charT>, 2> is_repeat_of<is_number<charT>, 2>
> >
>; >;
@@ -551,14 +551,14 @@ using is_key =
template<typename charT, typename is_array_component> template<typename charT, typename is_array_component>
using is_fixed_type_array = using is_fixed_type_array =
is_chain_of< is_chain_of<
is_charactor<charT, '['>, is_character<charT, '['>,
is_ignorable< is_ignorable<
is_repeat_of< is_repeat_of<
is_chain_of< is_chain_of<
is_ignorable<is_skippable_in_array<charT>>, is_ignorable<is_skippable_in_array<charT>>,
is_array_component, is_array_component,
is_ignorable<is_skippable_in_array<charT>>, is_ignorable<is_skippable_in_array<charT>>,
is_charactor<charT, ','> is_character<charT, ','>
>, >,
repeat_infinite() repeat_infinite()
> >
@@ -568,11 +568,11 @@ using is_fixed_type_array =
is_ignorable<is_skippable_in_array<charT>>, is_ignorable<is_skippable_in_array<charT>>,
is_array_component, is_array_component,
is_ignorable<is_skippable_in_array<charT>>, is_ignorable<is_skippable_in_array<charT>>,
is_ignorable<is_charactor<charT, ','>> is_ignorable<is_character<charT, ','>>
> >
>, >,
is_ignorable<is_skippable_in_array<charT>>, is_ignorable<is_skippable_in_array<charT>>,
is_charactor<charT, ']'> is_character<charT, ']'>
>; >;
template<typename charT> template<typename charT>
@@ -614,21 +614,21 @@ struct is_inline_table
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_key<charT>, is_key<charT>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_charactor<charT, '='>, is_character<charT, '='>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_component, is_component,
is_any_num_of_ws<charT> is_any_num_of_ws<charT>
> is_inline_key_value_pair; > is_inline_key_value_pair;
typedef is_chain_of< typedef is_chain_of<
is_charactor<charT, '{'>, is_character<charT, '{'>,
is_ignorable< is_ignorable<
is_repeat_of< is_repeat_of<
is_chain_of< is_chain_of<
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_inline_key_value_pair, is_inline_key_value_pair,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_charactor<charT, ','> is_character<charT, ','>
>, >,
repeat_infinite() repeat_infinite()
> >
@@ -638,11 +638,11 @@ struct is_inline_table
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_inline_key_value_pair, is_inline_key_value_pair,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_ignorable<is_charactor<charT, ','>> is_ignorable<is_character<charT, ','>>
> >
>, >,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_charactor<charT, '}'> is_character<charT, '}'>
> entity; > entity;
return entity::invoke(iter, end); return entity::invoke(iter, end);
} }
@@ -657,42 +657,42 @@ template<typename charT>
using is_table_definition = using is_table_definition =
is_chain_of< is_chain_of<
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_charactor<charT, '['>, is_character<charT, '['>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_key<charT>, is_key<charT>,
is_ignorable< is_ignorable<
is_repeat_of< is_repeat_of<
is_chain_of< is_chain_of<
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_charactor<charT, '.'>, is_character<charT, '.'>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_key<charT>, is_key<charT>,
is_any_num_of_ws<charT> is_any_num_of_ws<charT>
>, >,
repeat_infinite()> repeat_infinite()>
>, >,
is_charactor<charT, ']'> is_character<charT, ']'>
>; >;
template<typename charT> template<typename charT>
using is_array_of_table_definition = using is_array_of_table_definition =
is_chain_of< is_chain_of<
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_repeat_of<is_charactor<charT, '['>, 2>, is_repeat_of<is_character<charT, '['>, 2>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_key<charT>, is_key<charT>,
is_ignorable< is_ignorable<
is_repeat_of< is_repeat_of<
is_chain_of< is_chain_of<
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_charactor<charT, '.'>, is_character<charT, '.'>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_key<charT>, is_key<charT>,
is_any_num_of_ws<charT> is_any_num_of_ws<charT>
>, >,
repeat_infinite()> repeat_infinite()>
>, >,
is_repeat_of<is_charactor<charT, ']'>, 2> is_repeat_of<is_character<charT, ']'>, 2>
>; >;
template<typename charT> template<typename charT>
@@ -701,7 +701,7 @@ using is_key_value_pair =
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_key<charT>, is_key<charT>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_charactor<charT, '='>, is_character<charT, '='>,
is_any_num_of_ws<charT>, is_any_num_of_ws<charT>,
is_value<charT>, is_value<charT>,
is_any_num_of_ws<charT> is_any_num_of_ws<charT>

151
toml/format.hpp
View File

@@ -2,8 +2,8 @@
#define TOML11_FORMAT #define TOML11_FORMAT
#include "value.hpp" #include "value.hpp"
#include <type_traits> #include <type_traits>
#include <sstream>
#include <iostream> #include <iostream>
#include <sstream>
#include <iomanip> #include <iomanip>
#include <locale> #include <locale>
@@ -16,24 +16,24 @@ namespace toml
// std::cout << toml::make_inline(80) << value; // std::cout << toml::make_inline(80) << value;
// std::cout << toml::forceinline << value; // std::cout << toml::forceinline << value;
template<typename traits = std::char_traits<toml::charactor>, template<typename traits = std::char_traits<toml::character>,
typename alloc = std::allocator<toml::charactor>> typename alloc = std::allocator<toml::character>>
std::basic_string<toml::charactor, traits, alloc> std::basic_string<toml::character, traits, alloc>
format(const value& v); format(const value& v);
template<typename traits = std::char_traits<toml::charactor>, template<typename traits = std::char_traits<toml::character>,
typename alloc = std::allocator<toml::charactor>> typename alloc = std::allocator<toml::character>>
std::basic_string<toml::charactor, traits, alloc> std::basic_string<toml::character, traits, alloc>
format(const value& v, std::size_t mk); format(const value& v, std::size_t mk);
template<typename traits = std::char_traits<toml::charactor>, template<typename traits = std::char_traits<toml::character>,
typename alloc = std::allocator<toml::charactor>> typename alloc = std::allocator<toml::character>>
std::basic_string<toml::charactor, traits, alloc> std::basic_string<toml::character, traits, alloc>
format(const toml::key& k, const value& v); format(const toml::key& k, const value& v);
template<typename traits = std::char_traits<toml::charactor>, template<typename traits = std::char_traits<toml::character>,
typename alloc = std::allocator<toml::charactor>> typename alloc = std::allocator<toml::character>>
std::basic_string<toml::charactor, traits, alloc> std::basic_string<toml::character, traits, alloc>
format(const toml::key& k, const value& v, std::size_t mk); format(const toml::key& k, const value& v, std::size_t mk);
template<value_t Type> template<value_t Type>
@@ -43,7 +43,7 @@ template<> struct format_impl<value_t::Boolean>
{ {
typedef detail::toml_default_type<value_t::Boolean>::type type; typedef detail::toml_default_type<value_t::Boolean>::type type;
std::basic_string<toml::charactor> std::basic_string<toml::character>
operator()(const type& val) operator()(const type& val)
{ {
return val ? "true" : "false"; return val ? "true" : "false";
@@ -54,7 +54,7 @@ template<> struct format_impl<value_t::Integer>
{ {
typedef detail::toml_default_type<value_t::Integer>::type type; typedef detail::toml_default_type<value_t::Integer>::type type;
std::basic_string<toml::charactor> std::basic_string<toml::character>
operator()(const type& val) operator()(const type& val)
{ {
return std::to_string(val); return std::to_string(val);
@@ -65,10 +65,10 @@ template<> struct format_impl<value_t::Float>
{ {
typedef detail::toml_default_type<value_t::Float>::type type; typedef detail::toml_default_type<value_t::Float>::type type;
std::basic_string<toml::charactor> std::basic_string<toml::character>
operator()(const type& val) operator()(const type& val)
{ {
std::basic_ostringstream<toml::charactor> oss; std::basic_ostringstream<toml::character> oss;
oss << std::showpoint << val; oss << std::showpoint << val;
if(oss.str().back() == '.') oss << '0'; if(oss.str().back() == '.') oss << '0';
return oss.str(); return oss.str();
@@ -84,7 +84,7 @@ template<> struct format_impl<value_t::String>
format_impl() : max_length(80){} format_impl() : max_length(80){}
format_impl(std::size_t mx) : max_length(mx){} format_impl(std::size_t mx) : max_length(mx){}
std::basic_string<toml::charactor> std::basic_string<toml::character>
operator()(const type& val) operator()(const type& val)
{ {
auto tmp = make_inline(val); auto tmp = make_inline(val);
@@ -95,10 +95,10 @@ template<> struct format_impl<value_t::String>
private: private:
std::basic_string<toml::charactor> std::basic_string<toml::character>
make_inline(std::basic_string<toml::charactor>&& val) make_inline(const std::basic_string<toml::character>& val)
{ {
std::basic_string<toml::charactor> str; std::basic_string<toml::character> str;
str += '"'; str += '"';
for(const auto& c : val) for(const auto& c : val)
{ {
@@ -114,11 +114,11 @@ template<> struct format_impl<value_t::String>
default: default:
{ {
str += 'u'; str += 'u';
std::basic_ostringstream<toml::charactor> oss; std::basic_ostringstream<toml::character> oss;
oss << std::setw(4) << std::setfill('0') << std::hex oss << std::setw(4) << std::setfill('0') << std::hex
<< static_cast<std::int8_t>(c); << static_cast<std::int8_t>(c);
auto hexdig = oss.str(); auto hexdig = oss.str();
std::transform(hexdig.begin(), hexdig.end(), std::toupper); std::transform(hexdig.begin(), hexdig.end(), hexdig.begin(), ::toupper);
str += oss.str(); str += oss.str();
break; break;
} }
@@ -141,10 +141,10 @@ template<> struct format_impl<value_t::String>
return str; return str;
} }
std::basic_string<toml::charactor> std::basic_string<toml::character>
convert_multiline(std::basic_string<toml::charactor>&& val) convert_multiline(std::basic_string<toml::character>&& val)
{ {
std::basic_string<toml::charactor> str; str.reserve(val.size() + 6); std::basic_string<toml::character> str; str.reserve(val.size() + 6);
str += "\"\"\"\n"; str += "\"\"\"\n";
std::size_t current = 0; std::size_t current = 0;
for(auto iter = val.begin()+1; iter != val.end()-1; ++iter) for(auto iter = val.begin()+1; iter != val.end()-1; ++iter)
@@ -178,10 +178,10 @@ template<> struct format_impl<value_t::Datetime>
{ {
typedef detail::toml_default_type<value_t::Datetime>::type type; typedef detail::toml_default_type<value_t::Datetime>::type type;
std::basic_string<toml::charactor> std::basic_string<toml::character>
operator()(const type& val) operator()(const type& val)
{ {
std::basic_ostringstream<toml::charactor> oss; std::basic_ostringstream<toml::character> oss;
oss << val; oss << val;
return oss.str(); return oss.str();
} }
@@ -194,12 +194,15 @@ template<> struct format_impl<value_t::Array>
std::size_t max_length; std::size_t max_length;
std::basic_string<toml::charactor> format_impl() : max_length(80){}
format_impl(std::size_t mx) : max_length(mx){}
std::basic_string<toml::character>
operator()(const type& val) operator()(const type& val)
{ {
std::basic_string<toml::charactor> retval; std::basic_string<toml::character> retval;
retval += '['; retval += '[';
for(const auto&& item : val) for(const auto& item : val)
{ {
auto tmp = format(val, max_length - 1); auto tmp = format(val, max_length - 1);
retval += tmp; retval += tmp;
@@ -207,7 +210,7 @@ template<> struct format_impl<value_t::Array>
if(tmp.size() * 2 > max_length) retval += '\n'; if(tmp.size() * 2 > max_length) retval += '\n';
} }
retval += ']'; retval += ']';
return ; return retval;
} }
}; };
@@ -216,23 +219,28 @@ template<> struct format_impl<value_t::Table>
{ {
typedef detail::toml_default_type<value_t::Table>::type type; typedef detail::toml_default_type<value_t::Table>::type type;
std::basic_string<toml::charactor> std::size_t max_length;
format_impl() : max_length(80){}
format_impl(std::size_t mx) : max_length(mx){}
std::basic_string<toml::character>
operator()(const type& val) operator()(const type& val)
{ {
std::basic_string<toml::charactor> retval; std::basic_string<toml::character> retval;
for(const auto&& item : val) for(const auto& item : val)
{ {
retval += val.first; retval += item.first;
retval += " = " retval += " = ";
retval += format(val.second); retval += format(item.second);
retval += '\n'; retval += '\n';
} }
return ; return retval;
} }
}; };
template<typename traits, typename alloc> template<typename traits, typename alloc>
std::basic_string<toml::charactor, traits, alloc> std::basic_string<toml::character, traits, alloc>
format(const value& v) format(const value& v)
{ {
switch(v.type()) switch(v.type())
@@ -244,23 +252,52 @@ format(const value& v)
case value_t::Datetime: return format_impl<value_t::Datetime>{}(v.template cast<value_t::Datetime>()); case value_t::Datetime: return format_impl<value_t::Datetime>{}(v.template cast<value_t::Datetime>());
case value_t::Array : return format_impl<value_t::Array >{}(v.template cast<value_t::Array >()); case value_t::Array : return format_impl<value_t::Array >{}(v.template cast<value_t::Array >());
case value_t::Table : return format_impl<value_t::Table >{}(v.template cast<value_t::Table >()); case value_t::Table : return format_impl<value_t::Table >{}(v.template cast<value_t::Table >());
case value_t::Empty : return format_impl<value_t::Empty >{}(v.template cast<value_t::Empty >()); case value_t::Empty : throw std::runtime_error("toml::format: empty value");
case value_t::Unknown : return format_impl<value_t::Unknown >{}(v.template cast<value_t::Unknown >()); case value_t::Unknown : throw std::runtime_error("toml::format: unknown value");
default throw std::logic_error("toml::format: unknown enum value"); default: throw std::logic_error("toml::format: unknown enum value");
} }
} }
template<typename traits, typename alloc> template<typename traits, typename alloc>
std::basic_string<toml::charactor, traits, alloc> std::basic_string<toml::character, traits, alloc>
format(std::basic_string<toml::charactor, traits, alloc>&& key, const value& val) format(const value& v, std::size_t inl)
{ {
std::basic_string<charT, traits, alloc> retval( switch(v.type())
std::forward<std::basic_string<charT, traits, alloc>>(key)); {
case value_t::Boolean : return format_impl<value_t::Boolean >{}(v.template cast<value_t::Boolean>());
case value_t::Integer : return format_impl<value_t::Integer >{}(v.template cast<value_t::Integer>());
case value_t::Float : return format_impl<value_t::Float >{}(v.template cast<value_t::Float>());
case value_t::String : return format_impl<value_t::String >{inl}(v.template cast<value_t::String>());
case value_t::Datetime: return format_impl<value_t::Datetime>{}(v.template cast<value_t::Datetime>());
case value_t::Array : return format_impl<value_t::Array >{inl}(v.template cast<value_t::Array>());
case value_t::Table : return format_impl<value_t::Table >{inl}(v.template cast<value_t::Table>());
case value_t::Empty : throw std::runtime_error("toml::format: empty value");
case value_t::Unknown : throw std::runtime_error("toml::format: unknown value");
default: throw std::logic_error("toml::format: unknown enum value");
}
}
template<typename traits, typename alloc>
std::basic_string<toml::character, traits, alloc>
format(std::basic_string<toml::character, traits, alloc> key, const value& val)
{
std::basic_string<toml::character, traits, alloc> retval(std::move(key));
retval += " = "; retval += " = ";
retval += format(val); retval += format(val);
return retval; return retval;
} }
template<typename traits, typename alloc>
std::basic_string<toml::character, traits, alloc>
format(std::basic_string<toml::character, traits, alloc> key, const value& val, std::size_t mk)
{
std::basic_string<toml::character, traits, alloc> retval(std::move(key));
retval += " = ";
retval += format(val, mk);
return retval;
}
// ----------------------------- stream operators ----------------------------- // ----------------------------- stream operators -----------------------------
namespace detail namespace detail
@@ -274,7 +311,7 @@ struct inline_limit
T limit; T limit;
inline_limit() = default; inline_limit() = default;
~inline_limit() = default; ~inline_limit() = default;
constexpr make_inline(T i): limit(i){} constexpr inline_limit(T i): limit(i){}
constexpr operator T() const {return limit;} constexpr operator T() const {return limit;}
static void callback(std::ios_base::event ev, std::ios_base& ios, int idx) static void callback(std::ios_base::event ev, std::ios_base& ios, int idx)
@@ -305,9 +342,9 @@ const int inline_limit<T>::index = std::ios_base::xalloc();
} //detail } //detail
template<typename sizeT, typename traits = std::char_traits<toml::charactor>> template<typename sizeT, typename traits = std::char_traits<toml::character>>
std::basic_ostream<toml::charactor, traits>& std::basic_ostream<toml::character, traits>&
operator<<(std::basic_ostream<toml::charactor, traits>& os, operator<<(std::basic_ostream<toml::character, traits>& os,
const detail::inline_limit<sizeT>& inl) const detail::inline_limit<sizeT>& inl)
{ {
void*& info = os.pword(detail::inline_limit<sizeT>::index); void*& info = os.pword(detail::inline_limit<sizeT>::index);
@@ -327,21 +364,21 @@ operator<<(std::basic_ostream<toml::charactor, traits>& os,
return os; return os;
} }
constexpr static detail::inline_limit<std::size_t> forceinline = constexpr static detail::inline_limit<std::size_t> forceinline(
detail::inline_limit(std::numeric_limits<std::size_t>::max()); std::numeric_limits<std::size_t>::max());
inline detail::inline_limit<std::size_t> make_inline(std::size_t sz) inline detail::inline_limit<std::size_t> make_inline(std::size_t sz)
{ {
return detail::inline_limit<std::size_t>(sz); return detail::inline_limit<std::size_t>(sz);
} }
template<typename T, typename traits = std::char_traits> template<typename T, typename traits = std::char_traits<toml::character>>
std::basic_ostream<toml::charactor, traits>& std::basic_ostream<toml::character, traits>&
operator<<(std::basic_ostream<toml::charactor, traits>& os, operator<<(std::basic_ostream<toml::character, traits>& os,
const toml::value& v) const toml::value& v)
{ {
std::size_t* info = std::size_t* info =
static_cast<std::size_t*>(os.pword(inline_limit<std::size_t>::index)); static_cast<std::size_t*>(os.pword(detail::inline_limit<std::size_t>::index));
return os << (info == nullptr ? toml::format(v) : toml::format(v, *info)); return os << (info == nullptr ? toml::format(v) : toml::format(v, *info));
} }

108
toml/parser.hpp
View File

@@ -56,7 +56,7 @@ struct result
struct parse_escape_sequence struct parse_escape_sequence
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef toml::String string_type; typedef toml::String string_type;
typedef detail::result<string_type> result_type; typedef detail::result<string_type> result_type;
@@ -105,36 +105,36 @@ struct parse_escape_sequence
static string_type utf8_to_char(const unsigned int codepoint) static string_type utf8_to_char(const unsigned int codepoint)
{ {
string_type charactor; string_type character;
if(codepoint < 0x80) if(codepoint < 0x80)
{ {
charactor += static_cast<unsigned char>(codepoint); character += static_cast<unsigned char>(codepoint);
} }
else if(codepoint < 0x800) else if(codepoint < 0x800)
{ {
charactor += static_cast<unsigned char>(0xC0| codepoint >> 6); character += static_cast<unsigned char>(0xC0| codepoint >> 6);
charactor += static_cast<unsigned char>(0x80|(codepoint & 0x3F)); character += static_cast<unsigned char>(0x80|(codepoint & 0x3F));
} }
else if(codepoint < 0x10000) else if(codepoint < 0x10000)
{ {
charactor += static_cast<unsigned char>(0xE0| codepoint >>12); character += static_cast<unsigned char>(0xE0| codepoint >>12);
charactor += static_cast<unsigned char>(0x80|(codepoint >>6&0x3F)); character += static_cast<unsigned char>(0x80|(codepoint >>6&0x3F));
charactor += static_cast<unsigned char>(0x80|(codepoint & 0x3F)); character += static_cast<unsigned char>(0x80|(codepoint & 0x3F));
} }
else else
{ {
charactor += static_cast<unsigned char>(0xF0| codepoint >>18); character += static_cast<unsigned char>(0xF0| codepoint >>18);
charactor += static_cast<unsigned char>(0x80|(codepoint >>12&0x3F)); character += static_cast<unsigned char>(0x80|(codepoint >>12&0x3F));
charactor += static_cast<unsigned char>(0x80|(codepoint >>6 &0x3F)); character += static_cast<unsigned char>(0x80|(codepoint >>6 &0x3F));
charactor += static_cast<unsigned char>(0x80|(codepoint & 0x3F)); character += static_cast<unsigned char>(0x80|(codepoint & 0x3F));
} }
return charactor; return character;
} }
}; };
struct parse_basic_inline_string struct parse_basic_inline_string
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::String> result_type; typedef detail::result<toml::String> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -174,11 +174,11 @@ struct parse_basic_inline_string
struct parse_basic_multiline_string struct parse_basic_multiline_string
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef toml::String string_type; typedef toml::String string_type;
typedef detail::result<string_type> result_type; typedef detail::result<string_type> result_type;
typedef is_chain_of<is_charactor<value_type, '\\'>, is_newline<value_type>> typedef is_chain_of<is_character<value_type, '\\'>, is_newline<value_type>>
is_line_ending_backslash; is_line_ending_backslash;
typedef is_repeat_of<is_one_of<is_whitespace<value_type>, is_newline<value_type>>, typedef is_repeat_of<is_one_of<is_whitespace<value_type>, is_newline<value_type>>,
repeat_infinite()> ws_nl_after_backslash_remover; repeat_infinite()> ws_nl_after_backslash_remover;
@@ -228,7 +228,7 @@ struct parse_basic_multiline_string
struct parse_literal_inline_string struct parse_literal_inline_string
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::String> result_type; typedef detail::result<toml::String> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -257,10 +257,10 @@ struct parse_literal_inline_string
struct parse_literal_multiline_string struct parse_literal_multiline_string
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::String> result_type; typedef detail::result<toml::String> result_type;
typedef is_chain_of<is_charactor<value_type, '\\'>, is_newline<value_type>> typedef is_chain_of<is_character<value_type, '\\'>, is_newline<value_type>>
is_line_ending_backslash; is_line_ending_backslash;
typedef is_repeat_of<is_one_of<is_whitespace<value_type>, is_newline<value_type>>, typedef is_repeat_of<is_one_of<is_whitespace<value_type>, is_newline<value_type>>,
repeat_infinite()> ws_nl_after_backslash_remover; repeat_infinite()> ws_nl_after_backslash_remover;
@@ -292,7 +292,7 @@ struct parse_literal_multiline_string
struct parse_string struct parse_string
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::String> result_type; typedef detail::result<toml::String> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -317,7 +317,7 @@ struct parse_string
struct parse_integer struct parse_integer
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef std::basic_string<value_type> string_type; typedef std::basic_string<value_type> string_type;
typedef detail::result<toml::Integer> result_type; typedef detail::result<toml::Integer> result_type;
@@ -337,7 +337,7 @@ struct parse_integer
struct parse_float struct parse_float
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef std::basic_string<value_type> string_type; typedef std::basic_string<value_type> string_type;
typedef detail::result<toml::Float> result_type; typedef detail::result<toml::Float> result_type;
@@ -366,7 +366,7 @@ struct parse_float
struct parse_boolean struct parse_boolean
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::Boolean> result_type; typedef detail::result<toml::Boolean> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -383,14 +383,14 @@ struct parse_boolean
struct parse_local_time struct parse_local_time
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef std::basic_string<value_type> string_type; typedef std::basic_string<value_type> string_type;
typedef detail::result<toml::Datetime> result_type; typedef detail::result<toml::Datetime> result_type;
typedef typename toml::Datetime::number_type number_type; typedef typename toml::Datetime::number_type number_type;
template<std::size_t N> template<std::size_t N>
using nums = is_repeat_of<is_number<toml::charactor>, N>; using nums = is_repeat_of<is_number<toml::character>, N>;
typedef is_charactor<toml::charactor, ':'> delim; typedef is_character<toml::character, ':'> delim;
typedef is_charactor<toml::charactor, '.'> fract; typedef is_character<toml::character, '.'> fract;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type, std::is_same<typename std::iterator_traits<Iterator>::value_type,
@@ -445,12 +445,12 @@ struct parse_local_time
struct parse_local_date struct parse_local_date
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef std::basic_string<value_type> string_type; typedef std::basic_string<value_type> string_type;
typedef detail::result<toml::Datetime> result_type; typedef detail::result<toml::Datetime> result_type;
template<std::size_t N> template<std::size_t N>
using nums = is_repeat_of<is_number<value_type>, N>; using nums = is_repeat_of<is_number<value_type>, N>;
typedef is_charactor<value_type, '-'> delim; typedef is_character<value_type, '-'> delim;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type, std::is_same<typename std::iterator_traits<Iterator>::value_type,
@@ -481,12 +481,12 @@ struct parse_local_date
struct parse_local_date_time struct parse_local_date_time
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef std::basic_string<value_type> string_type; typedef std::basic_string<value_type> string_type;
typedef detail::result<toml::Datetime> result_type; typedef detail::result<toml::Datetime> result_type;
template<std::size_t N> template<std::size_t N>
using nums = is_repeat_of<is_number<toml::charactor>, N>; using nums = is_repeat_of<is_number<toml::character>, N>;
typedef is_charactor<toml::charactor, 'T'> delim; typedef is_character<toml::character, 'T'> delim;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type, std::is_same<typename std::iterator_traits<Iterator>::value_type,
@@ -517,12 +517,12 @@ struct parse_local_date_time
struct parse_offset_date_time struct parse_offset_date_time
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef std::basic_string<value_type> string_type; typedef std::basic_string<value_type> string_type;
typedef detail::result<toml::Datetime> result_type; typedef detail::result<toml::Datetime> result_type;
template<std::size_t N> template<std::size_t N>
using nums = is_repeat_of<is_number<toml::charactor>, N>; using nums = is_repeat_of<is_number<toml::character>, N>;
typedef is_charactor<toml::charactor, ':'> delim; typedef is_character<toml::character, ':'> delim;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type, std::is_same<typename std::iterator_traits<Iterator>::value_type,
@@ -561,7 +561,7 @@ struct parse_offset_date_time
struct parse_datetime struct parse_datetime
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::Datetime> result_type; typedef detail::result<toml::Datetime> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -587,7 +587,7 @@ struct parse_datetime
template<typename acceptorT, typename parserT> template<typename acceptorT, typename parserT>
struct parse_fixed_type_array struct parse_fixed_type_array
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::Array> result_type; typedef detail::result<toml::Array> result_type;
typedef acceptorT acceptor_type; typedef acceptorT acceptor_type;
typedef parserT parser_type; typedef parserT parser_type;
@@ -614,7 +614,7 @@ struct parse_fixed_type_array
result.emplace_back(next.first.move()); result.emplace_back(next.first.move());
iter = tmp; iter = tmp;
iter = skippable::invoke(iter, last); iter = skippable::invoke(iter, last);
iter = is_charactor<value_type, ','>::invoke(iter, last); iter = is_character<value_type, ','>::invoke(iter, last);
iter = skippable::invoke(iter, last); iter = skippable::invoke(iter, last);
} }
return std::make_pair(result, end); return std::make_pair(result, end);
@@ -628,7 +628,7 @@ template<typename charT>
struct parse_array struct parse_array
{ {
typedef charT value_type; typedef charT value_type;
static_assert(std::is_same<charT, toml::charactor>::value, ""); static_assert(std::is_same<charT, toml::character>::value, "");
typedef detail::result<toml::Array> result_type; typedef detail::result<toml::Array> result_type;
typedef is_skippable_in_array<value_type> skippable; typedef is_skippable_in_array<value_type> skippable;
@@ -669,7 +669,7 @@ template<typename charT>
struct parse_value struct parse_value
{ {
typedef charT value_type; typedef charT value_type;
static_assert(std::is_same<charT, toml::charactor>::value, ""); static_assert(std::is_same<charT, toml::character>::value, "");
typedef detail::result<toml::value> result_type; typedef detail::result<toml::value> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -700,7 +700,7 @@ struct parse_value
struct parse_barekey struct parse_barekey
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::key> result_type; typedef detail::result<toml::key> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -717,7 +717,7 @@ struct parse_barekey
struct parse_key struct parse_key
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<toml::key> result_type; typedef detail::result<toml::key> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -739,7 +739,7 @@ template<typename charT>
struct parse_key_value_pair struct parse_key_value_pair
{ {
typedef charT value_type; typedef charT value_type;
static_assert(std::is_same<charT, toml::charactor>::value, ""); static_assert(std::is_same<charT, toml::character>::value, "");
typedef detail::result<std::pair<toml::key, toml::value>> result_type; typedef detail::result<std::pair<toml::key, toml::value>> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -755,7 +755,7 @@ struct parse_key_value_pair
if(*iter != '=') throw syntax_error("invalid key value pair"); if(*iter != '=') throw syntax_error("invalid key value pair");
iter = is_any_num_of_ws<charT>::invoke(std::next(iter), range_end); iter = is_any_num_of_ws<charT>::invoke(std::next(iter), range_end);
auto tmp_value = parse_value<toml::charactor>::invoke(iter, range_end); auto tmp_value = parse_value<toml::character>::invoke(iter, range_end);
if(!tmp_value.first.ok()) if(!tmp_value.first.ok())
throw syntax_error("invalid key value pair"); throw syntax_error("invalid key value pair");
@@ -771,7 +771,7 @@ template<typename charT>
struct parse_inline_table struct parse_inline_table
{ {
typedef charT value_type; typedef charT value_type;
static_assert(std::is_same<charT, toml::charactor>::value, ""); static_assert(std::is_same<charT, toml::character>::value, "");
typedef detail::result<toml::Table> result_type; typedef detail::result<toml::Table> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -796,7 +796,7 @@ struct parse_inline_table
iter = tmp.second; iter = tmp.second;
iter = is_any_num_of_ws<value_type>::invoke(iter, last); iter = is_any_num_of_ws<value_type>::invoke(iter, last);
iter = is_charactor<value_type, ','>::invoke(iter, last); iter = is_character<value_type, ','>::invoke(iter, last);
iter = is_any_num_of_ws<value_type>::invoke(iter, last); iter = is_any_num_of_ws<value_type>::invoke(iter, last);
} }
return std::make_pair(result, end); return std::make_pair(result, end);
@@ -805,7 +805,7 @@ struct parse_inline_table
struct parse_table_definition struct parse_table_definition
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<std::vector<toml::key>> result_type; typedef detail::result<std::vector<toml::key>> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -832,7 +832,7 @@ struct parse_table_definition
while(iter != last) while(iter != last)
{ {
iter = is_charactor<value_type, '.'>::invoke(iter, last); iter = is_character<value_type, '.'>::invoke(iter, last);
iter = is_any_num_of_ws<value_type>::invoke(iter, last); iter = is_any_num_of_ws<value_type>::invoke(iter, last);
tmp = parse_key::invoke(iter, last); tmp = parse_key::invoke(iter, last);
@@ -846,7 +846,7 @@ struct parse_table_definition
struct parse_array_of_table_definition struct parse_array_of_table_definition
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef detail::result<std::vector<toml::key>> result_type; typedef detail::result<std::vector<toml::key>> result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -876,7 +876,7 @@ struct parse_array_of_table_definition
while(iter != last) while(iter != last)
{ {
iter = is_charactor<value_type, '.'>::invoke(iter, last); iter = is_character<value_type, '.'>::invoke(iter, last);
iter = is_any_num_of_ws<value_type>::invoke(iter, last); iter = is_any_num_of_ws<value_type>::invoke(iter, last);
tmp = parse_key::invoke(iter, last); tmp = parse_key::invoke(iter, last);
@@ -890,7 +890,7 @@ struct parse_array_of_table_definition
struct parse_data struct parse_data
{ {
typedef toml::charactor value_type; typedef toml::character value_type;
typedef toml::Table result_type; typedef toml::Table result_type;
template<typename Iterator, class = typename std::enable_if< template<typename Iterator, class = typename std::enable_if<
@@ -1055,15 +1055,15 @@ struct parse_data
}; };
template<typename traits = std::char_traits<toml::charactor>> template<typename traits = std::char_traits<toml::character>>
toml::Table parse(std::basic_istream<toml::charactor, traits>& is) toml::Table parse(std::basic_istream<toml::character, traits>& is)
{ {
const auto initial = is.tellg(); const auto initial = is.tellg();
is.seekg(0, std::ios::end); is.seekg(0, std::ios::end);
const auto eofpos = is.tellg(); const auto eofpos = is.tellg();
const std::size_t size = eofpos - initial; const std::size_t size = eofpos - initial;
is.seekg(initial); is.seekg(initial);
std::vector<toml::charactor> contents(size); std::vector<toml::character> contents(size);
is.read(contents.data(), size); is.read(contents.data(), size);
return parse_data::invoke(contents.cbegin(), contents.cend()); return parse_data::invoke(contents.cbegin(), contents.cend());
} }

10
toml/value.hpp
View File

@@ -13,15 +13,15 @@
namespace toml namespace toml
{ {
using charactor = char; using character = char;
class value; class value;
using key = std::basic_string<charactor>; using key = std::basic_string<character>;
using Boolean = bool; using Boolean = bool;
using Integer = std::int64_t; using Integer = std::int64_t;
using Float = double; using Float = double;
using String = std::basic_string<charactor>; using String = std::basic_string<character>;
using Datetime = basic_datetime<unsigned int, int>; using Datetime = basic_datetime<unsigned int, int>;
using Array = std::vector<value>; using Array = std::vector<value>;
using Table = std::unordered_map<key, value>; using Table = std::unordered_map<key, value>;
@@ -39,7 +39,7 @@ enum class value_t : std::uint8_t
Unknown = 255, Unknown = 255,
}; };
template<typename charT = charactor, typename traits = std::char_traits<charT>> template<typename charT = character, typename traits = std::char_traits<charT>>
inline std::basic_ostream<charT, traits>& inline std::basic_ostream<charT, traits>&
operator<<(std::basic_ostream<charT, traits>& os, value_t t) operator<<(std::basic_ostream<charT, traits>& os, value_t t)
{ {
@@ -58,7 +58,7 @@ operator<<(std::basic_ostream<charT, traits>& os, value_t t)
} }
} }
template<typename charT = charactor, typename traits = std::char_traits<charT>, template<typename charT = character, typename traits = std::char_traits<charT>,
typename alloc = std::allocator<charT>> typename alloc = std::allocator<charT>>
inline std::basic_string<charT, traits, alloc> inline std::basic_string<charT, traits, alloc>
stringize(value_t t) stringize(value_t t)