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

change impl of parser of values

Browse Source
This commit is contained in:
ToruNiina
2017-05-11 15:09:11 +09:00
parent 855cbe5aff
commit 6ab05a8594
2 changed files with 711 additions and 642 deletions
Download Patch File Download Diff File Expand all files Collapse all files

556
tests/test_parser.cpp
View File

@@ -1,4 +1,4 @@
#define BOOST_TEST_MODULE "test_barekey" #define BOOST_TEST_MODULE "test_parser"
#ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST #ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#else #else
@@ -317,7 +317,7 @@ BOOST_AUTO_TEST_CASE(test_parse_boolean)
BOOST_CHECK(result.second == acceptor::invoke(source.begin())); BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
} }
{ {
const std::string source("T"); const std::string source("dummy");
const auto result = parser::invoke(source.cbegin()); const auto result = parser::invoke(source.cbegin());
BOOST_CHECK(!result.first.ok()); BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin()); BOOST_CHECK(result.second == source.begin());
@@ -326,257 +326,307 @@ 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<char> parser; typedef toml::parse_local_time parser;
// typedef toml::is_local_time<char> acceptor; typedef toml::is_local_time<toml::charactor> 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);
// const toml::Datetime result = parser::invoke( const auto result = parser::invoke(source.cbegin());
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK(result.first.ok());
// BOOST_CHECK_EQUAL(result, expected); BOOST_CHECK_EQUAL(result.first.get(), expected);
// } BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// { }
// const std::string source("12:34:56.7"); {
// const toml::Datetime expected(12, 34, 56, 700, 0); const std::string source("12:34:56.7");
// const toml::Datetime result = parser::invoke( const toml::Datetime expected(12, 34, 56, 700, 0);
// source.cbegin(), acceptor::invoke(source.cbegin())); const auto result = parser::invoke(source.cbegin());
// BOOST_CHECK_EQUAL(result, expected); BOOST_CHECK(result.first.ok());
// } BOOST_CHECK_EQUAL(result.first.get(), expected);
// { BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const std::string source("12:34:56.7891"); }
// const toml::Datetime expected(12, 34, 56, 789, 100); {
// const toml::Datetime result = parser::invoke( const std::string source("12:34:56.7891");
// source.cbegin(), acceptor::invoke(source.cbegin())); const toml::Datetime expected(12, 34, 56, 789, 100);
// BOOST_CHECK_EQUAL(result, expected); const auto result = parser::invoke(source.cbegin());
// } BOOST_CHECK(result.first.ok());
// } BOOST_CHECK_EQUAL(result.first.get(), expected);
// BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// BOOST_AUTO_TEST_CASE(test_parse_local_date) }
// { }
// typedef toml::parse_local_date<char> parser;
// typedef toml::is_local_date<char> acceptor; BOOST_AUTO_TEST_CASE(test_parse_local_date)
// { {
// const std::string source("1979-09-27"); typedef toml::parse_local_date parser;
// const toml::Datetime expected(1979, 9, 27); typedef toml::is_local_date<toml::charactor> acceptor;
// const toml::Datetime result = parser::invoke( {
// source.cbegin(), acceptor::invoke(source.cbegin())); const std::string source("1979-09-27");
// BOOST_CHECK_EQUAL(result, expected); const toml::Datetime expected(1979, 9, 27);
// } const auto result = parser::invoke(source.cbegin());
// } BOOST_CHECK(result.first.ok());
// BOOST_CHECK_EQUAL(result.first.get(), expected);
// BOOST_AUTO_TEST_CASE(test_parse_local_date_time) BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// { }
// typedef toml::parse_local_date_time<char> parser; }
// typedef toml::is_local_date_time<char> acceptor;
// { BOOST_AUTO_TEST_CASE(test_parse_local_date_time)
// const std::string source("1979-09-27T12:34:56"); {
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0); typedef toml::parse_local_date_time parser;
// const toml::Datetime result = parser::invoke( typedef toml::is_local_date_time<toml::charactor> acceptor;
// source.cbegin(), acceptor::invoke(source.cbegin())); {
// BOOST_CHECK_EQUAL(result, expected); const std::string source("1979-09-27T12:34:56");
// } const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0);
// { const auto result = parser::invoke(source.cbegin());
// const std::string source("1979-09-27T12:34:56.789000"); BOOST_CHECK(result.first.ok());
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0); BOOST_CHECK_EQUAL(result.first.get(), expected);
// const toml::Datetime result = parser::invoke( BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// source.cbegin(), acceptor::invoke(source.cbegin())); }
// BOOST_CHECK_EQUAL(result, expected); {
// } const std::string source("1979-09-27T12:34:56.789000");
// } const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0);
// const auto result = parser::invoke(source.cbegin());
// BOOST_AUTO_TEST_CASE(test_parse_offset_date_time) BOOST_CHECK(result.first.ok());
// { BOOST_CHECK_EQUAL(result.first.get(), expected);
// typedef toml::parse_offset_date_time<char> parser; BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// typedef toml::is_offset_date_time<char> acceptor; }
// { }
// const std::string source("1979-09-27T12:34:56Z");
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0); BOOST_AUTO_TEST_CASE(test_parse_offset_date_time)
// const toml::Datetime result = parser::invoke( {
// source.cbegin(), acceptor::invoke(source.cbegin())); typedef toml::parse_offset_date_time parser;
// BOOST_CHECK_EQUAL(result, expected); typedef toml::is_offset_date_time<toml::charactor> acceptor;
// } {
// { const std::string source("1979-09-27T12:34:56Z");
// const std::string source("1979-09-27T12:34:56.789000Z"); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0);
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0, 0, 0); const auto result = parser::invoke(source.cbegin());
// const toml::Datetime result = parser::invoke( BOOST_CHECK(result.first.ok());
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK_EQUAL(result.first.get(), expected);
// BOOST_CHECK_EQUAL(result, expected); BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// } }
// {
// { const std::string source("1979-09-27T12:34:56.789000Z");
// const std::string source("1979-09-27T12:34:56+07:30"); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0, 0, 0);
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 7, 30); const auto result = parser::invoke(source.cbegin());
// const toml::Datetime result = parser::invoke( BOOST_CHECK(result.first.ok());
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK_EQUAL(result.first.get(), expected);
// BOOST_CHECK_EQUAL(result, expected); BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// } }
// {
// const std::string source("1979-09-27T12:34:56.789000+07:30"); {
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0, 7, 30); const std::string source("1979-09-27T12:34:56+07:30");
// const toml::Datetime result = parser::invoke( const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 7, 30);
// source.cbegin(), acceptor::invoke(source.cbegin())); const auto result = parser::invoke(source.cbegin());
// BOOST_CHECK_EQUAL(result, expected); BOOST_CHECK(result.first.ok());
// } BOOST_CHECK_EQUAL(result.first.get(), expected);
// BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// { }
// const std::string source("1979-09-27T12:34:56-07:30"); {
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, -7, -30); const std::string source("1979-09-27T12:34:56.789000+07:30");
// const toml::Datetime result = parser::invoke( const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0, 7, 30);
// source.cbegin(), acceptor::invoke(source.cbegin())); const auto result = parser::invoke(source.cbegin());
// BOOST_CHECK_EQUAL(result, expected); BOOST_CHECK(result.first.ok());
// } BOOST_CHECK_EQUAL(result.first.get(), expected);
// { BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const std::string source("1979-09-27T12:34:56.789000-07:30"); }
// const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0, -7, -30);
// const toml::Datetime result = parser::invoke( {
// source.cbegin(), acceptor::invoke(source.cbegin())); const std::string source("1979-09-27T12:34:56-07:30");
// BOOST_CHECK_EQUAL(result, expected); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, -7, -30);
// } const auto result = parser::invoke(source.cbegin());
// } BOOST_CHECK(result.first.ok());
// BOOST_CHECK_EQUAL(result.first.get(), expected);
// BOOST_AUTO_TEST_CASE(test_parse_array) BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// { }
// typedef toml::parse_array<char> parser; {
// typedef toml::is_array<char> acceptor; const std::string source("1979-09-27T12:34:56.789000-07:30");
// { const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0, -7, -30);
// const std::string source("[1,2,3]"); const auto result = parser::invoke(source.cbegin());
// const toml::Array expected{1, 2, 3}; BOOST_CHECK(result.first.ok());
// const toml::Array result = parser::invoke( BOOST_CHECK_EQUAL(result.first.get(), expected);
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const bool check = result == expected; }
// BOOST_CHECK(check); }
// }
// { BOOST_AUTO_TEST_CASE(test_parse_datetime)
// const std::string source("[1, 2, 3]"); {
// const toml::Array expected{1, 2, 3}; typedef toml::parse_datetime parser;
// const toml::Array result = parser::invoke( typedef toml::is_datetime<toml::charactor> acceptor;
// source.cbegin(), acceptor::invoke(source.cbegin())); {
// const bool check = result == expected; const std::string source("1979-09-27T12:34:56Z");
// BOOST_CHECK(check); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0);
// } const auto result = parser::invoke(source.cbegin());
// { BOOST_CHECK(result.first.ok());
// const std::string source("[ 1,2,3 ]"); BOOST_CHECK_EQUAL(result.first.get(), expected);
// const toml::Array expected{1, 2, 3}; BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const toml::Array result = parser::invoke( }
// source.cbegin(), acceptor::invoke(source.cbegin())); {
// const bool check = result == expected; const std::string source("1979-09-27T12:34:56");
// BOOST_CHECK(check); const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0);
// } const auto result = parser::invoke(source.cbegin());
// { BOOST_CHECK(result.first.ok());
// const std::string source("[ 1 , 2 , 3 ]"); BOOST_CHECK_EQUAL(result.first.get(), expected);
// const toml::Array expected{1, 2, 3}; BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const toml::Array result = parser::invoke( }
// source.cbegin(), acceptor::invoke(source.cbegin())); {
// const bool check = result == expected; const std::string source("1979-09-27");
// BOOST_CHECK(check); const toml::Datetime expected(1979, 9, 27);
// } const auto result = parser::invoke(source.cbegin());
// { BOOST_CHECK(result.first.ok());
// const std::string source("[ 1 \n,#comment\n 2 ,\n 3\n ]"); BOOST_CHECK_EQUAL(result.first.get(), expected);
// const toml::Array expected{1, 2, 3}; BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const toml::Array result = parser::invoke( }
// source.cbegin(), acceptor::invoke(source.cbegin())); {
// const bool check = result == expected; const std::string source("12:34:56");
// BOOST_CHECK(check); const toml::Datetime expected(12, 34, 56, 0, 0);
// } const auto result = parser::invoke(source.cbegin());
// { BOOST_CHECK(result.first.ok());
// const std::string source("[ # empty array\n ]"); BOOST_CHECK_EQUAL(result.first.get(), expected);
// const toml::Array expected{}; BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const toml::Array result = parser::invoke( }
// source.cbegin(), acceptor::invoke(source.cbegin())); }
// const bool check = result == expected;
// BOOST_CHECK(check);
// } BOOST_AUTO_TEST_CASE(test_parse_array)
// { {
// const std::string source("[ \"] \", ' # ', \n']', # ] \n]"); typedef toml::parse_array<toml::charactor> parser;
// const toml::Array expected{"] ", " # ", "]"}; typedef toml::is_array<toml::charactor> acceptor;
// const toml::Array result = parser::invoke( {
// source.cbegin(), acceptor::invoke(source.cbegin())); const std::string source("[1,2,3]");
// const bool check = result == expected; const toml::Array expected{1, 2, 3};
// BOOST_CHECK(check); const auto result = parser::invoke(source.cbegin());
// } BOOST_CHECK(result.first.ok());
// BOOST_CHECK(result.first.get() == expected);
// { BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const std::string source("[ \"Test #11 ]proved that\", 'Experiment #9 was a success' ]"); }
// const toml::Array expected{"Test #11 ]proved that", "Experiment #9 was a success"}; {
// const toml::Array result = parser::invoke( const std::string source("[1, 2, 3]");
// source.cbegin(), acceptor::invoke(source.cbegin())); const toml::Array expected{1, 2, 3};
// const bool check = result == expected; const auto result = parser::invoke(source.cbegin());
// BOOST_CHECK(check); BOOST_CHECK(result.first.ok());
// } BOOST_CHECK(result.first.get() == expected);
// BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// { }
// const std::string source("[ \"Test #11 ]proved that\", 'Experiment #9 was a success' ]"); {
// const toml::Array expected{"Test #11 ]proved that", "Experiment #9 was a success"}; const std::string source("[ 1,2,3 ]");
// const toml::Array result = parser::invoke( const toml::Array expected{1, 2, 3};
// source.cbegin(), acceptor::invoke(source.cbegin())); const auto result = parser::invoke(source.cbegin());
// const bool check = result == expected; BOOST_CHECK(result.first.ok());
// BOOST_CHECK(check); BOOST_CHECK(result.first.get() == expected);
// } BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// }
// { {
// const std::string source("[ [1,2,3] , ['a', 'b', 'c'] ]"); const std::string source("[ 1 , 2 , 3 ]");
// const toml::Array expected{{1,2,3}, {"a", "b", "c"}}; const toml::Array expected{1, 2, 3};
// const toml::Array result = parser::invoke( const auto result = parser::invoke(source.cbegin());
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK(result.first.ok());
// const bool check = result == expected; BOOST_CHECK(result.first.get() == expected);
// BOOST_CHECK(check); BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// } }
// {
// { const std::string source("[ 1 \n,#comment\n 2 ,\n 3\n ]");
// const std::string source("[ {foo=1}, {foo=1, bar=2.0}, {foo=1, bar=2.0, baz='str'} ]"); const toml::Array expected{1, 2, 3};
// const toml::Array expected{{{"foo", 1}}, {{"foo", 1}, {"bar", 2.0}}, {{"foo", 1}, {"bar", 2.0}, {"baz", "str"}}}; const auto result = parser::invoke(source.cbegin());
// const toml::Array result = parser::invoke( BOOST_CHECK(result.first.ok());
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK(result.first.get() == expected);
// BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const bool check = result == expected; }
// BOOST_CHECK(check); {
// } const std::string source("[ # empty array\n ]");
// } const toml::Array expected{};
// const auto result = parser::invoke(source.cbegin());
// BOOST_CHECK(result.first.ok());
// BOOST_AUTO_TEST_CASE(test_parse_inline_table) BOOST_CHECK(result.first.get() == expected);
// { BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// typedef toml::parse_inline_table<char> parser; }
// typedef toml::is_inline_table<char> acceptor; {
// { const std::string source("[ \"] \", ' # ', \n']', # ] \n]");
// const std::string source("{foo=1,bar=2.0,baz='str'}"); const toml::Array expected{"] ", " # ", "]"};
// const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}}; const auto result = parser::invoke(source.cbegin());
// const toml::Table result = parser::invoke( BOOST_CHECK(result.first.ok());
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK(result.first.get() == expected);
// const bool check = result == expected; BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// BOOST_CHECK(check); }
// }
// { {
// const std::string source("{ foo=1, bar=2.0, baz='str' }"); const std::string source("[ \"Test #11 ]proved that\", 'Experiment #9 was a success' ]");
// const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}}; const toml::Array expected{"Test #11 ]proved that", "Experiment #9 was a success"};
// const toml::Table result = parser::invoke( const auto result = parser::invoke(source.cbegin());
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK(result.first.ok());
// const bool check = result == expected; BOOST_CHECK(result.first.get() == expected);
// BOOST_CHECK(check); BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// } }
// {
// const std::string source("{ foo = 1, bar = 2.0, baz = 'str' }"); {
// const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}}; const std::string source("[ \"Test #11 ]proved that\", 'Experiment #9 was a success' ]");
// const toml::Table result = parser::invoke( const toml::Array expected{"Test #11 ]proved that", "Experiment #9 was a success"};
// source.cbegin(), acceptor::invoke(source.cbegin())); const auto result = parser::invoke(source.cbegin());
// const bool check = result == expected; BOOST_CHECK(result.first.ok());
// BOOST_CHECK(check); BOOST_CHECK(result.first.get() == expected);
// } BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// }
// {
// const std::string source("{b=true, i=1, f=2.0, d=1907-03-02T07:32:00, s='str', a=[1,2,3], t={foo=1}}"); {
// const toml::Table expected{{"b", true}, {"i", 1}, {"f", 2.0}, const std::string source("[ [1,2,3] , ['a', 'b', 'c'] ]");
// {"d", toml::Datetime(1907,3,2,7,32,0,0,0)}, const toml::Array expected{{1,2,3}, {"a", "b", "c"}};
// {"s", "str"}, {"a", {1, 2, 3}}, const auto result = parser::invoke(source.cbegin());
// {"t", {{"foo", 1}}}}; BOOST_CHECK(result.first.ok());
// const toml::Table result = parser::invoke( BOOST_CHECK(result.first.get() == expected);
// source.cbegin(), acceptor::invoke(source.cbegin())); BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
// const bool check = result == expected; }
// BOOST_CHECK(check);
// } {
// } const std::string source("[ {foo=1}, {foo=1, bar=2.0}, {foo=1, bar=2.0, baz='str'} ]");
const toml::Array expected{{{"foo", 1}}, {{"foo", 1}, {"bar", 2.0}}, {{"foo", 1}, {"bar", 2.0}, {"baz", "str"}}};
const auto result = parser::invoke(source.cbegin());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
}
}
BOOST_AUTO_TEST_CASE(test_parse_inline_table)
{
typedef toml::parse_inline_table<toml::charactor> parser;
typedef toml::is_inline_table<toml::charactor> acceptor;
{
const std::string source("{foo=1,bar=2.0,baz='str'}");
const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}};
const auto result = parser::invoke(source.cbegin());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
}
{
const std::string source("{ foo=1, bar=2.0, baz='str' }");
const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}};
const auto result = parser::invoke(source.cbegin());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
}
{
const std::string source("{ foo = 1, bar = 2.0, baz = 'str' }");
const toml::Table expected{{"foo", 1}, {"bar", 2.0}, {"baz", "str"}};
const auto result = parser::invoke(source.cbegin());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
}
{
const std::string source("{b=true, i=1, f=2.0, d=1907-03-02T07:32:00, s='str', a=[1,2,3], t={foo=1}}");
const toml::Table expected{{"b", true}, {"i", 1}, {"f", 2.0},
{"d", toml::Datetime(1907,3,2,7,32,0,0,0)},
{"s", "str"}, {"a", {1, 2, 3}},
{"t", {{"foo", 1}}}};
const auto result = parser::invoke(source.cbegin());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
}
}
// //
// // BOOST_AUTO_TEST_CASE(test_parse_barekey) // // BOOST_AUTO_TEST_CASE(test_parse_barekey)
// // { // // {

797
toml/parser.hpp
View File

@@ -349,395 +349,414 @@ struct parse_boolean
} }
}; };
// template<typename charT> struct parse_local_time
// struct parse_local_time {
// { typedef toml::charactor value_type;
// typedef charT 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 toml::Datetime result_type; typedef typename toml::Datetime::number_type number_type;
// typedef typename result_type::number_type number_type; template<std::size_t N>
// typedef is_repeat_of<is_number<charT>, 2> nums; using nums = is_repeat_of<is_number<toml::charactor>, N>;
// typedef is_charactor<charT, ':'> delim; typedef is_charactor<toml::charactor, ':'> delim;
// typedef is_charactor<charT, '.'> fract; typedef is_charactor<toml::charactor, '.'> 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,
// value_type>::value>::type> value_type>::value>::type>
// static result_type invoke(Iterator iter, Iterator end) static std::pair<result_type, Iterator> invoke(Iterator iter)
// { {
// result_type result; const Iterator end = is_local_time<value_type>::invoke(iter);
// result.hour = std::stoi(string_type(iter, nums::invoke(iter))); if(iter == end) return std::make_pair(result_type{}, iter);
// iter = delim::invoke(nums::invoke(iter));
// result.minute = std::stoi(string_type(iter, nums::invoke(iter))); toml::Datetime result;
// iter = delim::invoke(nums::invoke(iter)); result.hour = std::stoi(string_type(iter, nums<2>::invoke(iter)));
// result.second = std::stoi(string_type(iter, nums::invoke(iter))); iter = delim::invoke(nums<2>::invoke(iter));
// iter = fract::invoke(nums::invoke(iter)); result.minute = std::stoi(string_type(iter, nums<2>::invoke(iter)));
// if(iter == end) iter = delim::invoke(nums<2>::invoke(iter));
// { result.second = std::stoi(string_type(iter, nums<2>::invoke(iter)));
// result.millisecond = 0.0; iter = fract::invoke(nums<2>::invoke(iter));
// result.microsecond = 0.0; if(iter == end)
// } {
// else if(std::distance(iter, end) <= 3) result.millisecond = 0.0;
// { result.microsecond = 0.0;
// result.millisecond = parse_number(iter, end); }
// result.microsecond = 0.0; else if(std::distance(iter, end) <= 3)
// } {
// else result.millisecond = parse_number(iter, end);
// { result.microsecond = 0.0;
// result.millisecond = parse_number(iter, iter + 3); }
// result.microsecond = parse_number(iter + 3, end); else
// } {
// result.offset_hour = result_type::nooffset; result.millisecond = parse_number(iter, iter + 3);
// result.offset_minute = result_type::nooffset; result.microsecond = parse_number(iter + 3, end);
// result.year = result_type::undef; }
// result.month = result_type::undef; result.offset_hour = toml::Datetime::nooffset;
// result.day = result_type::undef; result.offset_minute = toml::Datetime::nooffset;
// return result; result.year = toml::Datetime::undef;
// } result.month = toml::Datetime::undef;
// result.day = toml::Datetime::undef;
// template<typename Iterator, class = typename std::enable_if< return std::make_pair(result, end);
// std::is_same<typename std::iterator_traits<Iterator>::value_type, }
// value_type>::value>::type>
// static number_type parse_number(Iterator iter, Iterator end) template<typename Iterator, class = typename std::enable_if<
// { std::is_same<typename std::iterator_traits<Iterator>::value_type,
// if(std::distance(iter, end) > 3) end = iter + 3; value_type>::value>::type>
// string_type str(iter, end); static number_type parse_number(Iterator iter, Iterator end)
// while(str.size() < 3){str += '0';} {
// return std::stoi(str); if(std::distance(iter, end) > 3) end = iter + 3;
// } string_type str(iter, end);
// }; while(str.size() < 3){str += '0';}
// return std::stoi(str);
// template<typename charT> }
// struct parse_local_date };
// {
// typedef charT value_type; struct parse_local_date
// typedef std::basic_string<value_type> string_type; {
// typedef toml::Datetime result_type; typedef toml::charactor value_type;
// template<std::size_t N> typedef std::basic_string<value_type> string_type;
// using nums = is_repeat_of<is_number<charT>, N>; typedef detail::result<toml::Datetime> result_type;
// typedef is_charactor<charT, '-'> delim; template<std::size_t N>
// using nums = is_repeat_of<is_number<value_type>, N>;
// template<typename Iterator, class = typename std::enable_if< typedef is_charactor<value_type, '-'> delim;
// std::is_same<typename std::iterator_traits<Iterator>::value_type,
// value_type>::value>::type> template<typename Iterator, class = typename std::enable_if<
// static result_type invoke(Iterator iter, Iterator end) std::is_same<typename std::iterator_traits<Iterator>::value_type,
// { value_type>::value>::type>
// result_type result; static std::pair<result_type, Iterator> invoke(Iterator iter)
// result.year = std::stoi(string_type(iter, nums<4>::invoke(iter))); {
// iter = delim::invoke(nums<4>::invoke(iter)); const Iterator end = is_local_date<value_type>::invoke(iter);
// result.month = std::stoi(string_type(iter, nums<2>::invoke(iter))); if(iter == end) return std::make_pair(result_type{}, iter);
// iter = delim::invoke(nums<2>::invoke(iter));
// result.day = std::stoi(string_type(iter, nums<2>::invoke(iter))); toml::Datetime result;
// result.year = std::stoi(string_type(iter, nums<4>::invoke(iter)));
// result.offset_hour = result_type::nooffset; iter = delim::invoke(nums<4>::invoke(iter));
// result.offset_minute = result_type::nooffset; result.month = std::stoi(string_type(iter, nums<2>::invoke(iter)));
// result.hour = result_type::undef; iter = delim::invoke(nums<2>::invoke(iter));
// result.minute = result_type::undef; result.day = std::stoi(string_type(iter, nums<2>::invoke(iter)));
// result.second = result_type::undef;
// result.millisecond = result_type::undef; result.offset_hour = toml::Datetime::nooffset;
// result.microsecond = result_type::undef; result.offset_minute = toml::Datetime::nooffset;
// return result; result.hour = toml::Datetime::undef;
// } result.minute = toml::Datetime::undef;
// }; result.second = toml::Datetime::undef;
// result.millisecond = toml::Datetime::undef;
// template<typename charT> result.microsecond = toml::Datetime::undef;
// struct parse_local_date_time return std::make_pair(result, end);
// { }
// typedef charT value_type; };
// typedef std::basic_string<value_type> string_type;
// typedef toml::Datetime result_type; struct parse_local_date_time
// template<std::size_t N> {
// using nums = is_repeat_of<is_number<charT>, N>; typedef toml::charactor value_type;
// typedef is_charactor<charT, 'T'> delim; typedef std::basic_string<value_type> string_type;
// typedef detail::result<toml::Datetime> result_type;
// template<typename Iterator, class = typename std::enable_if< template<std::size_t N>
// std::is_same<typename std::iterator_traits<Iterator>::value_type, using nums = is_repeat_of<is_number<toml::charactor>, N>;
// value_type>::value>::type> typedef is_charactor<toml::charactor, 'T'> delim;
// static result_type invoke(Iterator iter, Iterator end)
// { template<typename Iterator, class = typename std::enable_if<
// const Iterator date = is_local_date<charT>::invoke(iter); std::is_same<typename std::iterator_traits<Iterator>::value_type,
// result_type result = parse_local_date<charT>::invoke(iter, date); value_type>::value>::type>
// iter = delim::invoke(date);// 'T' static std::pair<result_type, Iterator> invoke(Iterator iter)
// const result_type time = parse_local_time<charT>::invoke(iter, end); {
// result.hour = time.hour; const Iterator end = is_local_date_time<value_type>::invoke(iter);
// result.minute = time.minute; if(iter == end) return std::make_pair(result_type{}, iter);
// result.second = time.second;
// result.millisecond = time.millisecond; auto ld = parse_local_date::invoke(iter);
// result.microsecond = time.microsecond; if(!ld.first.ok()) throw syntax_error("invalid local datetime");
// result.offset_hour = result_type::nooffset; toml::Datetime result(ld.first.move());
// result.offset_minute = result_type::nooffset; iter = delim::invoke(ld.second);// 'T'
// return result;
// } const auto time = parse_local_time::invoke(iter);
// }; result.hour = time.first.get().hour;
// result.minute = time.first.get().minute;
// template<typename charT> result.second = time.first.get().second;
// struct parse_offset_date_time result.millisecond = time.first.get().millisecond;
// { result.microsecond = time.first.get().microsecond;
// typedef charT value_type; result.offset_hour = toml::Datetime::nooffset;
// typedef std::basic_string<value_type> string_type; result.offset_minute = toml::Datetime::nooffset;
// typedef toml::Datetime result_type; return std::make_pair(result, end);
// template<std::size_t N> }
// using nums = is_repeat_of<is_number<charT>, N>; };
// typedef is_charactor<charT, ':'> delim;
// struct parse_offset_date_time
// template<typename Iterator, class = typename std::enable_if< {
// std::is_same<typename std::iterator_traits<Iterator>::value_type, typedef toml::charactor value_type;
// value_type>::value>::type> typedef std::basic_string<value_type> string_type;
// static result_type invoke(Iterator iter, Iterator end) typedef detail::result<toml::Datetime> result_type;
// { template<std::size_t N>
// const Iterator datetime = is_local_date_time<charT>::invoke(iter); using nums = is_repeat_of<is_number<toml::charactor>, N>;
// result_type result = parse_local_date_time<charT>::invoke(iter, datetime); typedef is_charactor<toml::charactor, ':'> delim;
// iter = datetime;
// if(*iter == 'Z') template<typename Iterator, class = typename std::enable_if<
// { std::is_same<typename std::iterator_traits<Iterator>::value_type,
// result.offset_hour = 0; value_type>::value>::type>
// result.offset_minute = 0; static std::pair<result_type, Iterator> invoke(Iterator iter)
// } {
// else const Iterator end = is_offset_date_time<value_type>::invoke(iter);
// { if(iter == end) return std::make_pair(result_type{}, iter);
// if(*iter != '+' && *iter != '-')
// throw syntax_error("invalid offset-datetime"); auto ldt = parse_local_date_time::invoke(iter);
// const int sign = (*iter == '-') ? -1 : 1; if(!ldt.first.ok()) throw syntax_error("invalid offset datetime");
// ++iter; toml::Datetime result(ldt.first.move());
// result.offset_hour = sign * iter = ldt.second;
// std::stoi(string_type(iter, nums<2>::invoke(iter))); if(*iter == 'Z')
// iter = delim::invoke(nums<2>::invoke(iter)); {
// result.offset_minute = sign * result.offset_hour = 0;
// std::stoi(string_type(iter, nums<2>::invoke(iter))); result.offset_minute = 0;
// } }
// return result; else
// } {
// }; if(*iter != '+' && *iter != '-')
// throw syntax_error("invalid offset-datetime");
// template<typename charT> const int sign = (*iter == '-') ? -1 : 1;
// struct parse_datetime ++iter;
// { result.offset_hour = sign *
// typedef charT value_type; std::stoi(string_type(iter, nums<2>::invoke(iter)));
// typedef toml::Datetime result_type; iter = delim::invoke(nums<2>::invoke(iter));
// result.offset_minute = sign *
// template<typename Iterator, class = typename std::enable_if< std::stoi(string_type(iter, nums<2>::invoke(iter)));
// std::is_same<typename std::iterator_traits<Iterator>::value_type, }
// value_type>::value>::type> return std::make_pair(result, end);
// static result_type invoke(Iterator iter, Iterator end) }
// { };
// Iterator tmp = is_offset_date_time<value_type>::invoke(iter);
// if(tmp != iter) return parse_offset_date_time<value_type>::invoke(iter, tmp); struct parse_datetime
// tmp = is_local_date_time<value_type>::invoke(iter); {
// if(tmp != iter) return parse_local_date_time<value_type>::invoke(iter, tmp); typedef toml::charactor value_type;
// tmp = is_local_date<value_type>::invoke(iter); typedef detail::result<toml::Datetime> result_type;
// if(tmp != iter) return parse_local_date<value_type>::invoke(iter, tmp);
// tmp = is_local_time<value_type>::invoke(iter); template<typename Iterator, class = typename std::enable_if<
// if(tmp != iter) return parse_local_time<value_type>::invoke(iter, tmp); std::is_same<typename std::iterator_traits<Iterator>::value_type,
// throw internal_error("no datetime here"); value_type>::value>::type>
// } static std::pair<result_type, Iterator> invoke(Iterator iter)
// }; {
// std::pair<result_type, Iterator> result;
// template<typename charT, typename acceptorT, typename parserT> if((result = parse_offset_date_time::invoke(iter)).first.ok())
// struct parse_fixed_type_array return result;
// { else if((result = parse_local_date_time::invoke(iter)).first.ok())
// typedef charT value_type; return result;
// typedef toml::Array result_type; else if((result = parse_local_date::invoke(iter)).first.ok())
// typedef acceptorT acceptor_type; return result;
// typedef parserT parser_type; else if((result = parse_local_time::invoke(iter)).first.ok())
// typedef is_skippable_in_array<charT> skippable; return result;
// else
// template<typename Iterator, class = typename std::enable_if< return std::make_pair(result_type{}, iter);
// std::is_same<typename std::iterator_traits<Iterator>::value_type, }
// value_type>::value>::type> };
// static result_type invoke(Iterator iter, Iterator end)
// { template<typename acceptorT, typename parserT>
// result_type result; struct parse_fixed_type_array
// --end; {
// assert(*iter == '[' && *end == ']'); typedef toml::charactor value_type;
// ++iter; typedef detail::result<toml::Array> result_type;
// iter = skippable::invoke(iter); typedef acceptorT acceptor_type;
// while(iter != end) typedef parserT parser_type;
// { typedef is_skippable_in_array<value_type> skippable;
// const Iterator tmp = acceptor_type::invoke(iter);
// result.emplace_back(parser_type::invoke(iter, tmp)); template<typename Iterator, class = typename std::enable_if<
// iter = tmp; std::is_same<typename std::iterator_traits<Iterator>::value_type,
// iter = skippable::invoke(iter); value_type>::value>::type>
// iter = is_charactor<charT, ','>::invoke(iter); static std::pair<result_type, Iterator> invoke(Iterator iter)
// iter = skippable::invoke(iter); {
// } const Iterator end = is_fixed_type_array<value_type, acceptorT>::invoke(iter);
// return result; if(iter == end) return std::make_pair(result_type{}, iter);
// }
// }; toml::Array result;
// const Iterator last = std::prev(end);
// template<typename charT> iter = skippable::invoke(std::next(iter));
// struct parse_inline_table; while(iter != last)
// {
// template<typename charT> const Iterator tmp = acceptor_type::invoke(iter);
// struct parse_array if(tmp == iter) throw syntax_error("parse_array");
// { auto next = parser_type::invoke(iter);
// typedef charT value_type; if(!next.first.ok()) throw syntax_error("parse_array");
// typedef toml::Array result_type; result.emplace_back(next.first.move());
// typedef is_skippable_in_array<charT> skippable; iter = tmp;
// iter = skippable::invoke(iter);
// template<typename Iterator, class = typename std::enable_if< iter = is_charactor<value_type, ','>::invoke(iter);
// std::is_same<typename std::iterator_traits<Iterator>::value_type, iter = skippable::invoke(iter);
// value_type>::value>::type> }
// static result_type invoke(Iterator iter, Iterator end) return std::make_pair(result, end);
// { }
// const Iterator init = skippable::invoke(std::next(iter)); };
// if(is_boolean<charT>::invoke(init) != init)
// return parse_fixed_type_array<charT, is_boolean<charT>, template<typename charT>
// parse_boolean<charT>>::invoke(iter, end); struct parse_inline_table;
//
// if(is_integer<charT>::invoke(init) != init) template<typename charT>
// return parse_fixed_type_array<charT, is_integer<charT>, struct parse_array
// parse_integer<charT>>::invoke(iter, end); {
// typedef charT value_type;
// if(is_float<charT>::invoke(init) != init) static_assert(std::is_same<charT, toml::charactor>::value, "");
// return parse_fixed_type_array<charT, is_float<charT>, typedef detail::result<toml::Array> result_type;
// parse_float<charT>>::invoke(iter, end); typedef is_skippable_in_array<value_type> skippable;
//
// if(is_string<charT>::invoke(init) != init) template<typename Iterator, class = typename std::enable_if<
// return parse_fixed_type_array<charT, is_string<charT>, std::is_same<typename std::iterator_traits<Iterator>::value_type,
// parse_string<charT>>::invoke(iter, end); value_type>::value>::type>
// static std::pair<result_type, Iterator> invoke(Iterator iter)
// if(is_datetime<charT>::invoke(init) != init) {
// return parse_fixed_type_array<charT, is_datetime<charT>, if(iter == is_array<value_type>::invoke(iter))
// parse_datetime<charT>>::invoke(iter, end); return std::make_pair(result_type{}, iter);
//
// if(is_array<charT>::invoke(init) != init) std::pair<result_type, Iterator> result;
// return parse_fixed_type_array<charT, is_array<charT>, if((result = parse_fixed_type_array<is_boolean<value_type>,
// parse_array<charT>>::invoke(iter, end); parse_boolean>::invoke(iter)).first.ok()) return result;
// else if((result = parse_fixed_type_array<is_string<value_type>,
// if(is_inline_table<charT>::invoke(init) != init) parse_string>::invoke(iter)).first.ok()) return result;
// return parse_fixed_type_array<charT, is_inline_table<charT>, else if((result = parse_fixed_type_array<is_datetime<value_type>,
// parse_inline_table<charT>>::invoke(iter, end); parse_datetime>::invoke(iter)).first.ok()) return result;
// else if((result = parse_fixed_type_array<is_float<value_type>,
// if(is_skippable_in_array<charT>::invoke(init) == std::prev(end)) parse_float>::invoke(iter)).first.ok()) return result;
// return result_type{}; // empty else if((result = parse_fixed_type_array<is_integer<value_type>,
// parse_integer>::invoke(iter)).first.ok()) return result;
// throw internal_error("no valid array here"); else if((result = parse_fixed_type_array<is_array<value_type>,
// } parse_array<value_type>>::invoke(iter)).first.ok()) return result;
// }; else if((result = parse_fixed_type_array<is_inline_table<value_type>,
// parse_inline_table<value_type>>::invoke(iter)).first.ok())
// template<typename charT> return result;
// struct parse_value else if(skippable::invoke(std::next(iter)) == // empty
// { std::prev(is_array<value_type>::invoke(iter))
// typedef charT value_type; ) return std::make_pair(
// typedef toml::value result_type; toml::Array{}, is_array<value_type>::invoke(iter));
// else throw syntax_error("no valid array here");
// template<typename Iterator, class = typename std::enable_if< }
// std::is_same<typename std::iterator_traits<Iterator>::value_type, };
// value_type>::value>::type>
// static result_type invoke(Iterator iter, Iterator end) template<typename charT>
// { struct parse_value
// if(iter != is_string<charT>::invoke(iter)) {
// return result_type(parse_string<charT>::invoke(iter, end)); typedef charT value_type;
// else if(iter != is_datetime<charT>::invoke(iter)) static_assert(std::is_same<charT, toml::charactor>::value, "");
// return result_type(parse_datetime<charT>::invoke(iter, end)); typedef detail::result<toml::value> result_type;
// else if(iter != is_float<charT>::invoke(iter))
// return result_type(parse_float<charT>::invoke(iter, end)); template<typename Iterator, class = typename std::enable_if<
// else if(iter != is_integer<charT>::invoke(iter)) std::is_same<typename std::iterator_traits<Iterator>::value_type,
// return result_type(parse_integer<charT>::invoke(iter, end)); value_type>::value>::type>
// else if(iter != is_boolean<charT>::invoke(iter)) static std::pair<result_type, Iterator> invoke(Iterator iter)
// return result_type(parse_boolean<charT>::invoke(iter, end)); {
// else if(iter != is_array<charT>::invoke(iter)) std::pair<result_type, Iterator> result;
// return result_type(parse_array<charT>::invoke(iter, end)); if((result = parse_boolean::invoke(iter)).first.ok())
// else if(iter != is_inline_table<charT>::invoke(iter)) return result;
// return result_type(parse_inline_table<charT>::invoke(iter, end)); else if((result = parse_string::invoke(iter)).first.ok())
// return result;
// throw internal_error("no valid value here"); else if((result = parse_datetime::invoke(iter)).first.ok())
// } return result;
// }; else if((result = parse_float::invoke(iter)).first.ok())
// return result;
// template<typename charT> else if((result = parse_integer::invoke(iter)).first.ok())
// struct parse_barekey return result;
// { else if((result = parse_array<value_type>::invoke(iter)).first.ok())
// typedef charT value_type; return result;
// typedef toml::key result_type; else if((result = parse_inline_table<value_type>::invoke(iter)).first.ok())
// static_assert(std::is_same<value_type, result_type::value_type return result;
// >::value, "char type is different from default key type"); else
// return std::make_pair(result_type{}, iter);
// template<typename Iterator, class = typename std::enable_if< }
// std::is_same<typename std::iterator_traits<Iterator>::value_type, };
// value_type>::value>::type>
// static result_type invoke(Iterator iter, Iterator end) struct parse_barekey
// { {
// return result_type(iter, end); typedef toml::charactor value_type;
// } typedef detail::result<toml::key> result_type;
// };
// template<typename Iterator, class = typename std::enable_if<
// template<typename charT> std::is_same<typename std::iterator_traits<Iterator>::value_type,
// struct parse_key value_type>::value>::type>
// { static std::pair<result_type, Iterator> invoke(Iterator iter)
// typedef charT value_type; {
// typedef toml::key result_type; const Iterator end = is_barekey<value_type>::invoke(iter);
// static_assert(std::is_same<value_type, result_type::value_type if(iter == end) return std::make_pair(result_type{}, iter);
// >::value, "char type is different from default key type"); return std::make_pair(toml::key(iter, end), end);
// }
// template<typename Iterator, class = typename std::enable_if< };
// std::is_same<typename std::iterator_traits<Iterator>::value_type,
// value_type>::value>::type> struct parse_key
// static result_type invoke(Iterator iter, Iterator end) {
// { typedef toml::charactor value_type;
// if(iter != is_barekey<charT>::invoke(iter)) typedef detail::result<toml::key> result_type;
// return parse_barekey<charT>::invoke(iter, end);
// else if(iter != is_string<charT>::invoke(iter)) template<typename Iterator, class = typename std::enable_if<
// return parse_string<charT>::invoke(iter, end); std::is_same<typename std::iterator_traits<Iterator>::value_type,
// throw internal_error("no valid key here"); value_type>::value>::type>
// } static std::pair<result_type, Iterator> invoke(Iterator iter)
// }; {
// std::pair<result_type, Iterator> result;
// template<typename charT> if((result = parse_barekey::invoke(iter)).first.ok())
// struct parse_key_value_pair return result;
// { else if((result = parse_string::invoke(iter)).first.ok())
// typedef charT value_type; return result;
// typedef std::pair<toml::key, toml::value> result_type; else return std::make_pair(result_type{}, iter);
// }
// template<typename Iterator, class = typename std::enable_if< };
// std::is_same<typename std::iterator_traits<Iterator>::value_type,
// value_type>::value>::type> template<typename charT>
// static result_type invoke(Iterator iter, Iterator end) struct parse_key_value_pair
// { {
// Iterator tmp = is_key<charT>::invoke(iter); typedef charT value_type;
// const toml::key k = parse_key<charT>::invoke(iter, tmp); static_assert(std::is_same<charT, toml::charactor>::value, "");
// iter = tmp; typedef detail::result<std::pair<toml::key, toml::value>> result_type;
// iter = is_any_num_of_ws<charT>::invoke(iter);
// assert(*iter == '='); ++iter; template<typename Iterator, class = typename std::enable_if<
// iter = is_any_num_of_ws<charT>::invoke(iter); std::is_same<typename std::iterator_traits<Iterator>::value_type,
// tmp = is_value<charT>::invoke(iter); value_type>::value>::type>
// const toml::value v = parse_value<charT>::invoke(iter, tmp); static std::pair<result_type, Iterator> invoke(Iterator iter)
// return std::make_pair(k, v); {
// } auto tmp_key = parse_key::invoke(iter);
// }; if(!tmp_key.first.ok())
// return std::make_pair(result_type{}, iter);
// template<typename charT> iter = is_any_num_of_ws<charT>::invoke(tmp_key.second);
// struct parse_inline_table if(*iter != '=') throw syntax_error("invalid key value pair");
// { iter = is_any_num_of_ws<charT>::invoke(std::next(iter));
// typedef charT value_type;
// typedef toml::Table result_type; auto tmp_value = parse_value<toml::charactor>::invoke(iter);
// if(!tmp_value.first.ok())
// template<typename Iterator, class = typename std::enable_if< throw syntax_error("invalid key value pair");
// std::is_same<typename std::iterator_traits<Iterator>::value_type,
// value_type>::value>::type> iter = tmp_value.second;
// static result_type invoke(Iterator iter, Iterator end)
// { return std::make_pair(std::make_pair(
// --end; tmp_key.first.move(), tmp_value.first.move()),
// assert(*iter == '{' && *end == '}'); is_any_num_of_ws<charT>::invoke(tmp_value.second));
// ++iter; }
// iter = is_any_num_of_ws<charT>::invoke(iter); };
//
// result_type result; template<typename charT>
// struct parse_inline_table
// while(iter != end) {
// { typedef charT value_type;
// Iterator tmp = is_key_value_pair<charT>::invoke(iter); static_assert(std::is_same<charT, toml::charactor>::value, "");
// result.emplace(parse_key_value_pair<charT>::invoke(iter, tmp)); typedef detail::result<toml::Table> result_type;
// iter = tmp;
// template<typename Iterator, class = typename std::enable_if<
// iter = is_any_num_of_ws<charT>::invoke(iter); std::is_same<typename std::iterator_traits<Iterator>::value_type,
// iter = is_charactor<charT, ','>::invoke(iter); value_type>::value>::type>
// iter = is_any_num_of_ws<charT>::invoke(iter); static std::pair<result_type, Iterator> invoke(Iterator iter)
// } {
// return result; const Iterator end = is_inline_table<value_type>::invoke(iter);
// } if(iter == end) return std::make_pair(result_type{}, iter);
// };
// iter = is_any_num_of_ws<value_type>::invoke(std::next(iter));
const Iterator last = std::prev(end);
toml::Table result;
while(iter != last)
{
auto tmp = parse_key_value_pair<value_type>::invoke(iter);
if(!tmp.first.ok()) throw syntax_error("parse_inline_table");
result.emplace(tmp.first.move());
iter = tmp.second;
iter = is_any_num_of_ws<value_type>::invoke(iter);
iter = is_charactor<value_type, ','>::invoke(iter);
iter = is_any_num_of_ws<value_type>::invoke(iter);
}
return std::make_pair(result, end);
}
};
// template<typename charT> // template<typename charT>
// struct parse_table_contents // struct parse_table_contents
// { // {