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

add Iterator pointing to the end of a range

Browse Source
This commit is contained in:
ToruNiina
2017-05-16 22:12:32 +09:00
parent 34193c4f8f
commit fe6a38737d
4 changed files with 574 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

361
tests/test_acceptor.cpp
View File

@@ -8,60 +8,53 @@
#include <toml/acceptor.hpp>
#include <iostream>
template<typename T>
struct wrapping_iterator
{
typedef T value_type;
typedef std::size_t difference_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef std::forward_iterator_tag iterator_category;
wrapping_iterator(value_type v) : value_(v){}
value_type operator*(){return value_;}
wrapping_iterator operator++() {advanced = true;return *this;}
wrapping_iterator operator++(int){advanced = true;return *this;}
operator bool() const {return advanced;}
private:
bool advanced = false;
value_type value_;
};
template<typename T>
inline wrapping_iterator<T> wrap(T v) {return wrapping_iterator<T>(v);}
BOOST_AUTO_TEST_CASE(test_conditions)
{
BOOST_CHECK( toml::is_space<char>::invoke(wrap(' ')));
BOOST_CHECK(!toml::is_space<char>::invoke(wrap('a')));
{
const std::string tmp(" ");
const std::string dummy("dummy");
BOOST_CHECK(toml::is_space<char>::invoke(tmp.begin(), tmp.end()) == tmp.end());
BOOST_CHECK(toml::is_space<char>::invoke(dummy.begin(), dummy.end()) == dummy.begin());
}
BOOST_CHECK( toml::is_tab<char>::invoke(wrap('\t')));
BOOST_CHECK(!toml::is_tab<char>::invoke(wrap('a')));
{
const std::string tmp("\t");
const std::string dummy("dummy");
BOOST_CHECK(toml::is_tab<char>::invoke(tmp.begin(), tmp.end()) == tmp.end());
BOOST_CHECK(toml::is_tab<char>::invoke(dummy.begin(), dummy.end()) == dummy.begin());
}
for(char c = '0'; c <= '9'; ++c)
BOOST_CHECK(toml::is_number<char>::invoke(wrap(c)));
BOOST_CHECK(!toml::is_number<char>::invoke(wrap('a')));
{
const std::string tmp("0123456789");
const std::string dummy("dummy");
BOOST_CHECK(toml::is_number<char>::invoke(tmp.begin(), tmp.end()) == tmp.end());
BOOST_CHECK(toml::is_number<char>::invoke(dummy.begin(), dummy.end()) == dummy.begin());
}
for(char c = 'a'; c <= 'z'; ++c)
BOOST_CHECK(toml::is_lowercase<char>::invoke(wrap(c)));
BOOST_CHECK(!toml::is_lowercase<char>::invoke(wrap('A')));
for(char c = 'A'; c <= 'Z'; ++c)
BOOST_CHECK(toml::is_uppercase<char>::invoke(wrap(c)));
BOOST_CHECK(!toml::is_uppercase<char>::invoke(wrap('a')));
BOOST_CHECK(toml::is_whitespace<char>::invoke(wrap(' ')));
BOOST_CHECK(toml::is_whitespace<char>::invoke(wrap('\t')));
std::string barekey("hoge1-piyo2_fuga3");
BOOST_CHECK(toml::is_barekey<char>::invoke(barekey.cbegin()) == barekey.cend());
std::string partial("hoge1.piyo2_fuga3");
BOOST_CHECK(toml::is_barekey<char>::invoke(partial.cbegin()) == partial.cbegin()+5);
{
const std::string tmp("abcdefghijklmnopqrstuvwxyz");
const std::string dummy("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
BOOST_CHECK(toml::is_lowercase<char>::invoke(tmp.begin(), tmp.end()) == tmp.end());
BOOST_CHECK(toml::is_lowercase<char>::invoke(dummy.begin(), dummy.end()) == dummy.begin());
}
{
const std::string tmp("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
const std::string dummy("abcdefghijklmnopqrstuvwxyz");
BOOST_CHECK(toml::is_uppercase<char>::invoke(tmp.begin(), tmp.end()) == tmp.end());
BOOST_CHECK(toml::is_uppercase<char>::invoke(dummy.begin(), dummy.end()) == dummy.begin());
}
{
const std::string tmp(" \t ");
const std::string dummy("abcdefghijklmnopqrstuvwxyz");
BOOST_CHECK(toml::is_whitespace<char>::invoke(tmp.begin(), tmp.end()) == tmp.end());
BOOST_CHECK(toml::is_whitespace<char>::invoke(dummy.begin(), dummy.end()) == dummy.begin());
}
{
const std::string tmp("hoge1-piyo2_fuga3");
const std::string dummy(" \t");
BOOST_CHECK(toml::is_barekey<char>::invoke(tmp.begin(), tmp.end()) == tmp.end());
BOOST_CHECK(toml::is_barekey<char>::invoke(dummy.begin(), dummy.end()) == dummy.begin());
}
}
BOOST_AUTO_TEST_CASE(test_basic_inline_string)
@@ -69,36 +62,36 @@ BOOST_AUTO_TEST_CASE(test_basic_inline_string)
using is_valid = toml::is_basic_inline_string<char>;
{
const std::string simple("\"hoge1-piyo2_fuga3\"");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
}
{
const std::string quote("\"hoge1-\\\"piyo2\\\"_fuga3\"");
BOOST_CHECK(is_valid::invoke(quote.cbegin()) == quote.cend());
BOOST_CHECK(is_valid::invoke(quote.cbegin(), quote.cend()) == quote.cend());
}
{
const std::string escape("\"I'm a string. \\\"You can quote me\\\". Name\\tJos\\u00E9\\nLocation\\tSF.\"");
BOOST_CHECK(is_valid::invoke(escape.cbegin()) == escape.cend());
BOOST_CHECK(is_valid::invoke(escape.cbegin(), escape.cend()) == escape.cend());
}
{
const std::string empty("\"\"");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
{
const std::string newline("\"newline\r\nhoge\"");
BOOST_CHECK(is_valid::invoke(newline.cbegin()) == newline.cbegin());
BOOST_CHECK(is_valid::invoke(newline.cbegin(), newline.cend()) == newline.cbegin());
}
{
const std::string invalid_escape("\"foo\\abar\"");
BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin()) == invalid_escape.cbegin());
BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin(), invalid_escape.cend()) == invalid_escape.cbegin());
}
{
const std::string invalid_charactor("\"foo\0bar\"");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin()) == invalid_charactor.cbegin());
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin());
}
{
const std::string multi("\"\"\"multiline\"\"\"");
BOOST_CHECK(is_valid::invoke(multi.cbegin()) == multi.cbegin());
BOOST_CHECK(is_valid::invoke(multi.cbegin(), multi.cend()) == multi.cbegin());
}
}
@@ -107,40 +100,40 @@ BOOST_AUTO_TEST_CASE(test_basic_multiline_string)
using is_valid = toml::is_basic_multiline_string<char>;
{
const std::string simple("\"\"\"foobar\"\"\"");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
}
{
const std::string quote("\"\"\"hoge1-\"piyo2\"_fuga3\"\"\"");
BOOST_CHECK(is_valid::invoke(quote.cbegin()) == quote.cend());
BOOST_CHECK(is_valid::invoke(quote.cbegin(), quote.cend()) == quote.cend());
}
{
const std::string newline("\"\"\"hoge1-\npiyo2_\r\nfuga3\"\"\"");
BOOST_CHECK(is_valid::invoke(newline.cbegin()) == newline.cend());
BOOST_CHECK(is_valid::invoke(newline.cbegin(), newline.cend()) == newline.cend());
}
{
const std::string escape("\"\"\"I'm a string. \"You can quote me\". Name\\tJos\\u00E9\\nLocation\\tSF.\"\"\"");
BOOST_CHECK(is_valid::invoke(escape.cbegin()) == escape.cend());
BOOST_CHECK(is_valid::invoke(escape.cbegin(), escape.cend()) == escape.cend());
}
{
const std::string empty("\"\"\"\"\"\"");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
{
const std::string ending_backslash("\"\"\"hoge\\\n piyo\\\n\"\"\"");
BOOST_CHECK(is_valid::invoke(ending_backslash.cbegin()) == ending_backslash.cend());
BOOST_CHECK(is_valid::invoke(ending_backslash.cbegin(), ending_backslash.cend()) == ending_backslash.cend());
}
{
const std::string invalid_escape("\"\"\"foo\\abar\"\"\"");
BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin()) == invalid_escape.cbegin());
BOOST_CHECK(is_valid::invoke(invalid_escape.cbegin(), invalid_escape.cend()) == invalid_escape.cbegin());
}
{
const std::string invalid_charactor("\"\"\"foo\0bar\"\"\"");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin()) == invalid_charactor.cbegin());
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin());
}
{
const std::string single("\"singleline\"");
BOOST_CHECK(is_valid::invoke(single.cbegin()) == single.cbegin());
BOOST_CHECK(is_valid::invoke(single.cbegin(), single.cend()) == single.cbegin());
}
}
@@ -149,32 +142,32 @@ BOOST_AUTO_TEST_CASE(test_literal_inline_string)
using is_valid = toml::is_literal_inline_string<char>;
{
const std::string simple("'foobar'");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
}
{
const std::string nonescape("'C:\\Users\\nodejs\\templates'");
BOOST_CHECK(is_valid::invoke(nonescape.cbegin()) == nonescape.cend());
BOOST_CHECK(is_valid::invoke(nonescape.cbegin(), nonescape.cend()) == nonescape.cend());
}
{
const std::string empty("''");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
{
const std::string quote("'hoge1-'piyo2'_fuga3'");
BOOST_CHECK(is_valid::invoke(quote.cbegin()) == quote.cbegin() + 8);
BOOST_CHECK(is_valid::invoke(quote.cbegin(), quote.cend()) == quote.cbegin() + 8);
}
{
const std::string newline("'hoge1-\npiyo2_\r\nfuga3'");
BOOST_CHECK(is_valid::invoke(newline.cbegin()) == newline.cbegin());
BOOST_CHECK(is_valid::invoke(newline.cbegin(), newline.cend()) == newline.cbegin());
}
{
const std::string invalid_charactor("'foo\0bar'");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin()) == invalid_charactor.cbegin());
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin());
}
{
const std::string multi("'''multiline'''");
BOOST_CHECK(is_valid::invoke(multi.cbegin()) == multi.cbegin());
BOOST_CHECK(is_valid::invoke(multi.cbegin(), multi.cend()) == multi.cbegin());
}
}
@@ -183,32 +176,32 @@ BOOST_AUTO_TEST_CASE(test_literal_multiline_string)
using is_valid = toml::is_literal_multiline_string<char>;
{
const std::string simple("'''foobar'''");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
}
{
const std::string quote("'''hoge1-'piyo2'_fuga3'''");
BOOST_CHECK(is_valid::invoke(quote.cbegin()) == quote.cend());
BOOST_CHECK(is_valid::invoke(quote.cbegin(), quote.cend()) == quote.cend());
}
{
const std::string nonescape("'''C:\\Users\\nodejs\\templates'''");
BOOST_CHECK(is_valid::invoke(nonescape.cbegin()) == nonescape.cend());
BOOST_CHECK(is_valid::invoke(nonescape.cbegin(), nonescape.cend()) == nonescape.cend());
}
{
const std::string newline("'''hoge1-\npiyo2_\r\nfuga3'''");
BOOST_CHECK(is_valid::invoke(newline.cbegin()) == newline.cend());
BOOST_CHECK(is_valid::invoke(newline.cbegin(), newline.cend()) == newline.cend());
}
{
const std::string empty("''''''");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
{
const std::string invalid_charactor("'''foo\0bar'''");
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin()) == invalid_charactor.cbegin());
BOOST_CHECK(is_valid::invoke(invalid_charactor.cbegin(), invalid_charactor.cend()) == invalid_charactor.cbegin());
}
{
const std::string single("'singleline'");
BOOST_CHECK(is_valid::invoke(single.cbegin()) == single.cbegin());
BOOST_CHECK(is_valid::invoke(single.cbegin(), single.cend()) == single.cbegin());
}
}
@@ -217,34 +210,34 @@ BOOST_AUTO_TEST_CASE(test_integer)
using is_valid = toml::is_integer<char>;
{
const std::string simple("1");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
}
{
const std::string psign("+1234");
BOOST_CHECK(is_valid::invoke(psign.cbegin()) == psign.cend());
BOOST_CHECK(is_valid::invoke(psign.cbegin(), psign.cend()) == psign.cend());
const std::string nsign("-1234");
BOOST_CHECK(is_valid::invoke(nsign.cbegin()) == nsign.cend());
BOOST_CHECK(is_valid::invoke(nsign.cbegin(), nsign.cend()) == nsign.cend());
}
{
const std::string zero("0");
BOOST_CHECK(is_valid::invoke(zero.cbegin()) == zero.cend());
BOOST_CHECK(is_valid::invoke(zero.cbegin(), zero.cend()) == zero.cend());
}
{
const std::string us("1_2_3_4_5");
BOOST_CHECK(is_valid::invoke(us.cbegin()) == us.cend());
BOOST_CHECK(is_valid::invoke(us.cbegin(), us.cend()) == us.cend());
}
{
const std::string f("12.34");
BOOST_CHECK(is_valid::invoke(f.cbegin()) == f.cbegin()+2);
BOOST_CHECK(is_valid::invoke(f.cbegin(), f.cend()) == f.cbegin()+2);
}
{
const std::string f("12e34");
BOOST_CHECK(is_valid::invoke(f.cbegin()) == f.cbegin()+2);
BOOST_CHECK(is_valid::invoke(f.cbegin(), f.cend()) == f.cbegin()+2);
}
{
const std::string ascii("1234a");
BOOST_CHECK(is_valid::invoke(ascii.cbegin()) == ascii.cbegin()+4);
BOOST_CHECK(is_valid::invoke(ascii.cbegin(), ascii.cend()) == ascii.cbegin()+4);
}
}
@@ -253,31 +246,31 @@ BOOST_AUTO_TEST_CASE(test_float)
using is_valid = toml::is_float<char>;
{
const std::string simplef("1.0");
BOOST_CHECK(is_valid::invoke(simplef.cbegin()) == simplef.cend());
BOOST_CHECK(is_valid::invoke(simplef.cbegin(), simplef.cend()) == simplef.cend());
const std::string simplee("1e0");
BOOST_CHECK(is_valid::invoke(simplee.cbegin()) == simplee.cend());
BOOST_CHECK(is_valid::invoke(simplee.cbegin(), simplee.cend()) == simplee.cend());
const std::string both("6.626e-34");
BOOST_CHECK(is_valid::invoke(both.cbegin()) == both.cend());
BOOST_CHECK(is_valid::invoke(both.cbegin(), both.cend()) == both.cend());
}
{
const std::string psign("+1.0");
BOOST_CHECK(is_valid::invoke(psign.cbegin()) == psign.cend());
BOOST_CHECK(is_valid::invoke(psign.cbegin(), psign.cend()) == psign.cend());
const std::string nsign("-1.0");
BOOST_CHECK(is_valid::invoke(nsign.cbegin()) == nsign.cend());
BOOST_CHECK(is_valid::invoke(nsign.cbegin(), nsign.cend()) == nsign.cend());
}
{
const std::string psmall("+0.001");
BOOST_CHECK(is_valid::invoke(psmall.cbegin()) == psmall.cend());
BOOST_CHECK(is_valid::invoke(psmall.cbegin(), psmall.cend()) == psmall.cend());
const std::string nsmall("-0.001");
BOOST_CHECK(is_valid::invoke(nsmall.cbegin()) == nsmall.cend());
BOOST_CHECK(is_valid::invoke(nsmall.cbegin(), nsmall.cend()) == nsmall.cend());
}
{
const std::string zero("0.0");
BOOST_CHECK(is_valid::invoke(zero.cbegin()) == zero.cend());
BOOST_CHECK(is_valid::invoke(zero.cbegin(), zero.cend()) == zero.cend());
}
{
const std::string us("9_224_617.445_991_228_313");
BOOST_CHECK(is_valid::invoke(us.cbegin()) == us.cend());
BOOST_CHECK(is_valid::invoke(us.cbegin(), us.cend()) == us.cend());
}
}
@@ -286,15 +279,15 @@ BOOST_AUTO_TEST_CASE(test_boolean)
using is_valid = toml::is_boolean<char>;
{
const std::string t("true");
BOOST_CHECK(is_valid::invoke(t.cbegin()) == t.cend());
BOOST_CHECK(is_valid::invoke(t.cbegin(), t.cend()) == t.cend());
const std::string f("false");
BOOST_CHECK(is_valid::invoke(f.cbegin()) == f.cend());
BOOST_CHECK(is_valid::invoke(f.cbegin(), f.cend()) == f.cend());
}
{
const std::string t("True");
BOOST_CHECK(is_valid::invoke(t.cbegin()) == t.cbegin());
BOOST_CHECK(is_valid::invoke(t.cbegin(), t.cend()) == t.cbegin());
const std::string f("False");
BOOST_CHECK(is_valid::invoke(f.cbegin()) == f.cbegin());
BOOST_CHECK(is_valid::invoke(f.cbegin(), f.cend()) == f.cbegin());
}
}
@@ -303,15 +296,15 @@ BOOST_AUTO_TEST_CASE(test_localtime)
using is_valid = toml::is_local_time<char>;
{
const std::string t("07:32:00");
BOOST_CHECK(is_valid::invoke(t.cbegin()) == t.cend());
BOOST_CHECK(is_valid::invoke(t.cbegin(), t.cend()) == t.cend());
const std::string tf("07:32:00.0000");
BOOST_CHECK(is_valid::invoke(tf.cbegin()) == tf.cend());
BOOST_CHECK(is_valid::invoke(tf.cbegin(), tf.cend()) == tf.cend());
}
{
const std::string d("1907-32-00");
BOOST_CHECK(is_valid::invoke(d.cbegin()) == d.cbegin());
BOOST_CHECK(is_valid::invoke(d.cbegin(), d.cend()) == d.cbegin());
const std::string f("1907:32:00");
BOOST_CHECK(is_valid::invoke(f.cbegin()) == f.cbegin());
BOOST_CHECK(is_valid::invoke(f.cbegin(), f.cend()) == f.cbegin());
}
}
@@ -320,13 +313,13 @@ BOOST_AUTO_TEST_CASE(test_localdate)
using is_valid = toml::is_local_date<char>;
{
const std::string d("1907-32-00");
BOOST_CHECK(is_valid::invoke(d.cbegin()) == d.cend());
BOOST_CHECK(is_valid::invoke(d.cbegin(), d.cend()) == d.cend());
}
{
const std::string t("07:32:00");
BOOST_CHECK(is_valid::invoke(t.cbegin()) == t.cbegin());
BOOST_CHECK(is_valid::invoke(t.cbegin(), t.cend()) == t.cbegin());
const std::string f("1907:32:00");
BOOST_CHECK(is_valid::invoke(f.cbegin()) == f.cbegin());
BOOST_CHECK(is_valid::invoke(f.cbegin(),f.cend()) == f.cbegin());
}
}
@@ -335,17 +328,17 @@ BOOST_AUTO_TEST_CASE(test_localdatetime)
using is_valid = toml::is_local_date_time<char>;
{
const std::string dt("1907-32-00T07:32:00");
BOOST_CHECK(is_valid::invoke(dt.cbegin()) == dt.cend());
BOOST_CHECK(is_valid::invoke(dt.cbegin(), dt.cend()) == dt.cend());
const std::string dtf("1907-32-00T07:32:00.0000");
BOOST_CHECK(is_valid::invoke(dtf.cbegin()) == dtf.cend());
BOOST_CHECK(is_valid::invoke(dtf.cbegin(), dtf.cend()) == dtf.cend());
}
{
const std::string d("1907-32-00");
BOOST_CHECK(is_valid::invoke(d.cbegin()) == d.cbegin());
BOOST_CHECK(is_valid::invoke(d.cbegin(), d.cend()) == d.cbegin());
const std::string t("07:32:00");
BOOST_CHECK(is_valid::invoke(t.cbegin()) == t.cbegin());
BOOST_CHECK(is_valid::invoke(t.cbegin(), t.cend()) == t.cbegin());
const std::string f("1907-32-00 07:32:00");
BOOST_CHECK(is_valid::invoke(f.cbegin()) == f.cbegin());
BOOST_CHECK(is_valid::invoke(f.cbegin(), f.cend()) == f.cbegin());
}
}
@@ -354,25 +347,25 @@ BOOST_AUTO_TEST_CASE(test_offsetdatetime)
using is_valid = toml::is_offset_date_time<char>;
{
const std::string dtZ("1907-32-00T07:32:00Z");
BOOST_CHECK(is_valid::invoke(dtZ.cbegin()) == dtZ.cend());
BOOST_CHECK(is_valid::invoke(dtZ.cbegin(), dtZ.cend()) == dtZ.cend());
const std::string dtfZ("1907-32-00T07:32:00.0000Z");
BOOST_CHECK(is_valid::invoke(dtfZ.cbegin()) == dtfZ.cend());
BOOST_CHECK(is_valid::invoke(dtfZ.cbegin(), dtfZ.cend()) == dtfZ.cend());
const std::string dtp("1907-32-00T07:32:00+12:34");
BOOST_CHECK(is_valid::invoke(dtp.cbegin()) == dtp.cend());
BOOST_CHECK(is_valid::invoke(dtp.cbegin(), dtp.cend()) == dtp.cend());
const std::string dtfp("1907-32-00T07:32:00.0000+12:34");
BOOST_CHECK(is_valid::invoke(dtfp.cbegin()) == dtfp.cend());
BOOST_CHECK(is_valid::invoke(dtfp.cbegin(), dtfp.cend()) == dtfp.cend());
const std::string dtn("1907-32-00T07:32:00-12:34");
BOOST_CHECK(is_valid::invoke(dtn.cbegin()) == dtn.cend());
BOOST_CHECK(is_valid::invoke(dtn.cbegin(), dtn.cend()) == dtn.cend());
const std::string dtfn("1907-32-00T07:32:00.0000-12:34");
BOOST_CHECK(is_valid::invoke(dtfn.cbegin()) == dtfn.cend());
BOOST_CHECK(is_valid::invoke(dtfn.cbegin(), dtfn.cend()) == dtfn.cend());
}
{
const std::string d("1907-32-00");
BOOST_CHECK(is_valid::invoke(d.cbegin()) == d.cbegin());
BOOST_CHECK(is_valid::invoke(d.cbegin(), d.cend()) == d.cbegin());
const std::string t("07:32:00");
BOOST_CHECK(is_valid::invoke(t.cbegin()) == t.cbegin());
BOOST_CHECK(is_valid::invoke(t.cbegin(), t.cend()) == t.cbegin());
const std::string l("1907-32-00T07:32:00");
BOOST_CHECK(is_valid::invoke(l.cbegin()) == l.cbegin());
BOOST_CHECK(is_valid::invoke(l.cbegin(), l.cend()) == l.cbegin());
}
}
@@ -381,42 +374,42 @@ BOOST_AUTO_TEST_CASE(test_array)
using is_valid = toml::is_array<char>;
{
const std::string arr0("[]");
BOOST_CHECK(is_valid::invoke(arr0.cbegin()) == arr0.cend());
BOOST_CHECK(is_valid::invoke(arr0.cbegin(), arr0.cend()) == arr0.cend());
const std::string arr1("[1,2,3]");
BOOST_CHECK(is_valid::invoke(arr1.cbegin()) == arr1.cend());
BOOST_CHECK(is_valid::invoke(arr1.cbegin(), arr1.cend()) == arr1.cend());
const std::string arr2("[ 1,2,3 ]");
BOOST_CHECK(is_valid::invoke(arr2.cbegin()) == arr2.cend());
BOOST_CHECK(is_valid::invoke(arr2.cbegin(), arr2.cend()) == arr2.cend());
const std::string arr3("[ 1, 2, 3 ]");
BOOST_CHECK(is_valid::invoke(arr3.cbegin()) == arr3.cend());
BOOST_CHECK(is_valid::invoke(arr3.cbegin(), arr3.cend()) == arr3.cend());
const std::string arr4("[ 1, 2, 3, ]");
BOOST_CHECK(is_valid::invoke(arr4.cbegin()) == arr4.cend());
BOOST_CHECK(is_valid::invoke(arr4.cbegin(), arr4.cend()) == arr4.cend());
const std::string arr5("[ 1, 2, 3,]");
BOOST_CHECK(is_valid::invoke(arr5.cbegin()) == arr5.cend());
BOOST_CHECK(is_valid::invoke(arr5.cbegin(), arr5.cend()) == arr5.cend());
const std::string arr6("[ 1 , 2 , 3 ,]");
BOOST_CHECK(is_valid::invoke(arr6.cbegin()) == arr6.cend());
BOOST_CHECK(is_valid::invoke(arr6.cbegin(), arr6.cend()) == arr6.cend());
}
{
const std::string arr1("[\"red\", \"yellow\", \"green\"]");
BOOST_CHECK(is_valid::invoke(arr1.cbegin()) == arr1.cend());
BOOST_CHECK(is_valid::invoke(arr1.cbegin(), arr1.cend()) == arr1.cend());
const std::string arr2("[\"]\", \"#\", \" \"]");
BOOST_CHECK(is_valid::invoke(arr2.cbegin()) == arr2.cend());
BOOST_CHECK(is_valid::invoke(arr2.cbegin(), arr2.cend()) == arr2.cend());
const std::string arr3("[[1, 2, 3], ['a', 'b', 'c']]");
BOOST_CHECK(is_valid::invoke(arr3.cbegin()) == arr3.cend());
BOOST_CHECK(is_valid::invoke(arr3.cbegin(), arr3.cend()) == arr3.cend());
const std::string arr4("[{hoge = 1}, {piyo = 'a'}, {fuga = [1,2,3]}]");
BOOST_CHECK(is_valid::invoke(arr4.cbegin()) == arr4.cend());
BOOST_CHECK(is_valid::invoke(arr4.cbegin(), arr4.cend()) == arr4.cend());
}
{
const std::string arr1("[1,\n2,#comment\n3]");
BOOST_CHECK(is_valid::invoke(arr1.cbegin()) == arr1.cend());
BOOST_CHECK(is_valid::invoke(arr1.cbegin(), arr1.cend()) == arr1.cend());
const std::string arr2("[#c\n1,\n2,#comment\r\n3]");
BOOST_CHECK(is_valid::invoke(arr2.cbegin()) == arr2.cend());
BOOST_CHECK(is_valid::invoke(arr2.cbegin(), arr2.cend()) == arr2.cend());
}
{
const std::string invalid("[1, 3.14, 'string']");
BOOST_CHECK(is_valid::invoke(invalid.cbegin()) == invalid.cbegin());
BOOST_CHECK(is_valid::invoke(invalid.cbegin(), invalid.cend()) == invalid.cbegin());
const std::string valid("[[1,2,3], [3.14, 2.71, 1.414], ['foo', 'bar']]");
BOOST_CHECK(is_valid::invoke(valid.cbegin()) == valid.cend());
BOOST_CHECK(is_valid::invoke(valid.cbegin(), valid.cend()) == valid.cend());
}
}
@@ -426,35 +419,35 @@ BOOST_AUTO_TEST_CASE(test_inline_table)
using is_valid = toml::is_inline_table<char>;
{
const std::string tab0("{}");
BOOST_CHECK(is_valid::invoke(tab0.cbegin()) == tab0.cend());
BOOST_CHECK(is_valid::invoke(tab0.cbegin(), tab0.cend()) == tab0.cend());
const std::string tab1("{hoge=1,piyo=2,fuga=3}");
BOOST_CHECK(is_valid::invoke(tab1.cbegin()) == tab1.cend());
BOOST_CHECK(is_valid::invoke(tab1.cbegin(), tab1.cend()) == tab1.cend());
const std::string tab2("{hoge=1, piyo=2, fuga=3}");
BOOST_CHECK(is_valid::invoke(tab2.cbegin()) == tab2.cend());
BOOST_CHECK(is_valid::invoke(tab2.cbegin(), tab2.cend()) == tab2.cend());
const std::string tab3("{ hoge=1, piyo=2, fuga=3 }");
BOOST_CHECK(is_valid::invoke(tab3.cbegin()) == tab3.cend());
BOOST_CHECK(is_valid::invoke(tab3.cbegin(), tab3.cend()) == tab3.cend());
const std::string tab4("{ hoge = 1, piyo = 2, fuga = 3 }");
BOOST_CHECK(is_valid::invoke(tab4.cbegin()) == tab4.cend());
BOOST_CHECK(is_valid::invoke(tab4.cbegin(), tab4.cend()) == tab4.cend());
const std::string tab5("{hoge = 1, piyo = 2, fuga = 3}");
BOOST_CHECK(is_valid::invoke(tab5.cbegin()) == tab5.cend());
BOOST_CHECK(is_valid::invoke(tab5.cbegin(), tab5.cend()) == tab5.cend());
const std::string tab6("{hoge = 1, piyo = 2, fuga = 3,}");
BOOST_CHECK(is_valid::invoke(tab6.cbegin()) == tab6.cend());
BOOST_CHECK(is_valid::invoke(tab6.cbegin(), tab6.cend()) == tab6.cend());
const std::string tab7("{hoge = 1, piyo = 2, fuga = 3, }");
BOOST_CHECK(is_valid::invoke(tab7.cbegin()) == tab7.cend());
BOOST_CHECK(is_valid::invoke(tab7.cbegin(), tab7.cend()) == tab7.cend());
}
{
const std::string tab0("{hoge = 1, piyo = 2.0}");
BOOST_CHECK(is_valid::invoke(tab0.cbegin()) == tab0.cend());
BOOST_CHECK(is_valid::invoke(tab0.cbegin(), tab0.cend()) == tab0.cend());
const std::string tab1("{hoge = [1,2,3], piyo = {fuga = {}}}");
BOOST_CHECK(is_valid::invoke(tab1.cbegin()) == tab1.cend());
BOOST_CHECK(is_valid::invoke(tab1.cbegin(), tab1.cend()) == tab1.cend());
const std::string tab2("{hoge = \"}\", piyo = \"#\"}");
BOOST_CHECK(is_valid::invoke(tab2.cbegin()) == tab2.cend());
BOOST_CHECK(is_valid::invoke(tab2.cbegin(), tab2.cend()) == tab2.cend());
const std::string tab3("{b=true, i=1, f=2.0, d=1907-03-02T07:32:00, s='str', a=[1,2,3], t={foo=1}}");
BOOST_CHECK(is_valid::invoke(tab3.cbegin()) == tab3.cend());
BOOST_CHECK(is_valid::invoke(tab3.cbegin(), tab3.cend()) == tab3.cend());
}
{
const std::string tab0("{hoge = \"}\",\n piyo = \"#\"}");
BOOST_CHECK(is_valid::invoke(tab0.cbegin()) == tab0.cbegin());
BOOST_CHECK(is_valid::invoke(tab0.cbegin(), tab0.cend()) == tab0.cbegin());
}
}
@@ -463,15 +456,15 @@ BOOST_AUTO_TEST_CASE(test_table_definition)
using is_valid = toml::is_table_definition<char>;
{
const std::string simple("[hoge]");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
const std::string dotted("[hoge.piyo.fuga]");
BOOST_CHECK(is_valid::invoke(dotted.cbegin()) == dotted.cend());
BOOST_CHECK(is_valid::invoke(dotted.cbegin(), dotted.cend()) == dotted.cend());
const std::string spaced_dotted("[hoge . piyo .fuga. foo]");
BOOST_CHECK(is_valid::invoke(spaced_dotted.cbegin()) == spaced_dotted.cend());
BOOST_CHECK(is_valid::invoke(spaced_dotted.cbegin(), spaced_dotted.cend()) == spaced_dotted.cend());
const std::string quoted("[\"hoge\"]");
BOOST_CHECK(is_valid::invoke(quoted.cbegin()) == quoted.cend());
BOOST_CHECK(is_valid::invoke(quoted.cbegin(), quoted.cend()) == quoted.cend());
const std::string quoted_dot("[\"hoge\".'piyo'.fuga]");
BOOST_CHECK(is_valid::invoke(quoted_dot.cbegin()) == quoted_dot.cend());
BOOST_CHECK(is_valid::invoke(quoted_dot.cbegin(), quoted_dot.cend()) == quoted_dot.cend());
}
}
@@ -480,15 +473,15 @@ BOOST_AUTO_TEST_CASE(test_array_of_table_definition)
using is_valid = toml::is_array_of_table_definition<char>;
{
const std::string simple("[[hoge]]");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
const std::string dotted("[[hoge.piyo.fuga]]");
BOOST_CHECK(is_valid::invoke(dotted.cbegin()) == dotted.cend());
BOOST_CHECK(is_valid::invoke(dotted.cbegin(), dotted.cend()) == dotted.cend());
const std::string spaced_dotted("[[hoge . piyo .fuga. foo]]");
BOOST_CHECK(is_valid::invoke(spaced_dotted.cbegin()) == spaced_dotted.cend());
BOOST_CHECK(is_valid::invoke(spaced_dotted.cbegin(), spaced_dotted.cend()) == spaced_dotted.cend());
const std::string quoted("[[\"hoge\"]]");
BOOST_CHECK(is_valid::invoke(quoted.cbegin()) == quoted.cend());
BOOST_CHECK(is_valid::invoke(quoted.cbegin(), quoted.cend()) == quoted.cend());
const std::string quoted_dot("[[\"hoge\".'piyo'.fuga]]");
BOOST_CHECK(is_valid::invoke(quoted_dot.cbegin()) == quoted_dot.cend());
BOOST_CHECK(is_valid::invoke(quoted_dot.cbegin(), quoted_dot.cend()) == quoted_dot.cend());
}
}
@@ -497,9 +490,9 @@ BOOST_AUTO_TEST_CASE(test_key)
using is_valid = toml::is_key<char>;
{
const std::string simple("foobar");
BOOST_CHECK(is_valid::invoke(simple.cbegin()) == simple.cend());
BOOST_CHECK(is_valid::invoke(simple.cbegin(), simple.cend()) == simple.cend());
const std::string quoted("\"foo#bar.baz\\n\"");
BOOST_CHECK(is_valid::invoke(quoted.cbegin()) == quoted.cend());
BOOST_CHECK(is_valid::invoke(quoted.cbegin(), quoted.cend()) == quoted.cend());
}
}
@@ -508,19 +501,19 @@ BOOST_AUTO_TEST_CASE(test_value)
using is_valid = toml::is_value<char>;
{
const std::string boolean("true");
BOOST_CHECK(is_valid::invoke(boolean.cbegin()) == boolean.cend());
BOOST_CHECK(is_valid::invoke(boolean.cbegin(), boolean.cend()) == boolean.cend());
const std::string integer("-42");
BOOST_CHECK(is_valid::invoke(integer.cbegin()) == integer.cend());
BOOST_CHECK(is_valid::invoke(integer.cbegin(), integer.cend()) == integer.cend());
const std::string floating("-42e0");
BOOST_CHECK(is_valid::invoke(floating.cbegin()) == floating.cend());
BOOST_CHECK(is_valid::invoke(floating.cbegin(), floating.cend()) == floating.cend());
const std::string string("\"string\"");
BOOST_CHECK(is_valid::invoke(string.cbegin()) == string.cend());
BOOST_CHECK(is_valid::invoke(string.cbegin(), string.cend()) == string.cend());
const std::string datetime("1901-01-01T00:00:00");
BOOST_CHECK(is_valid::invoke(datetime.cbegin()) == datetime.cend());
BOOST_CHECK(is_valid::invoke(datetime.cbegin(), datetime.cend()) == datetime.cend());
const std::string array("[1,2,3]");
BOOST_CHECK(is_valid::invoke(array.cbegin()) == array.cend());
BOOST_CHECK(is_valid::invoke(array.cbegin(), array.cend()) == array.cend());
const std::string table("{foo=1,bar=2.0,baz='3'}");
BOOST_CHECK(is_valid::invoke(table.cbegin()) == table.cend());
BOOST_CHECK(is_valid::invoke(table.cbegin(), table.cend()) == table.cend());
}
}
@@ -529,35 +522,35 @@ BOOST_AUTO_TEST_CASE(test_key_value_pair)
using is_valid = toml::is_key_value_pair<char>;
{
const std::string kv("key=1");
BOOST_CHECK(is_valid::invoke(kv.cbegin()) == kv.cend());
BOOST_CHECK(is_valid::invoke(kv.cbegin(), kv.cend()) == kv.cend());
}
{
const std::string kv("key = 1");
BOOST_CHECK(is_valid::invoke(kv.cbegin()) == kv.cend());
BOOST_CHECK(is_valid::invoke(kv.cbegin(), kv.cend()) == kv.cend());
}
{
const std::string kv(" key = 1");
BOOST_CHECK(is_valid::invoke(kv.cbegin()) == kv.cend());
BOOST_CHECK(is_valid::invoke(kv.cbegin(), kv.cend()) == kv.cend());
}
{
const std::string kv(" key = 1 ");
BOOST_CHECK(is_valid::invoke(kv.cbegin()) == kv.cend());
BOOST_CHECK(is_valid::invoke(kv.cbegin(), kv.cend()) == kv.cend());
}
{
const std::string boolean("key = true");
BOOST_CHECK(is_valid::invoke(boolean.cbegin()) == boolean.cend());
BOOST_CHECK(is_valid::invoke(boolean.cbegin(), boolean.cend()) == boolean.cend());
const std::string integer("key = -42");
BOOST_CHECK(is_valid::invoke(integer.cbegin()) == integer.cend());
BOOST_CHECK(is_valid::invoke(integer.cbegin(), integer.cend()) == integer.cend());
const std::string floating("key = -42.0");
BOOST_CHECK(is_valid::invoke(floating.cbegin()) == floating.cend());
BOOST_CHECK(is_valid::invoke(floating.cbegin(), floating.cend()) == floating.cend());
const std::string string("key = \"string\"");
BOOST_CHECK(is_valid::invoke(string.cbegin()) == string.cend());
BOOST_CHECK(is_valid::invoke(string.cbegin(), string.cend()) == string.cend());
const std::string datetime("key = 1901-01-01T00:00:00");
BOOST_CHECK(is_valid::invoke(datetime.cbegin()) == datetime.cend());
BOOST_CHECK(is_valid::invoke(datetime.cbegin(), datetime.cend()) == datetime.cend());
const std::string array("key = [1,2,3]");
BOOST_CHECK(is_valid::invoke(array.cbegin()) == array.cend());
BOOST_CHECK(is_valid::invoke(array.cbegin(), array.cend()) == array.cend());
const std::string table("key = {foo=1,bar=2.0,baz='3'}");
BOOST_CHECK(is_valid::invoke(table.cbegin()) == table.cend());
BOOST_CHECK(is_valid::invoke(table.cbegin(), table.cend()) == table.cend());
}
}
@@ -566,18 +559,18 @@ BOOST_AUTO_TEST_CASE(test_empty_line)
using is_valid = toml::is_empty_line<char>;
{
const std::string empty("\n");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
{
const std::string empty(" \n");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
{
const std::string empty("#comment\n");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
{
const std::string empty(" #comment\n");
BOOST_CHECK(is_valid::invoke(empty.cbegin()) == empty.cend());
BOOST_CHECK(is_valid::invoke(empty.cbegin(), empty.cend()) == empty.cend());
}
}

356
tests/test_parser.cpp
View File

@@ -18,22 +18,22 @@ BOOST_AUTO_TEST_CASE(test_parse_basic_inline_string)
{
const std::string source("\"simple\"");
const std::string expected("simple");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("\"I'm a string. \\\"You can quote me\\\". Name\\tJos\\u00E9\\nLocation\\tSF.\"");
const std::string expected("I'm a string. \"You can quote me\". Name\tJosé\nLocation\tSF.");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -47,30 +47,30 @@ BOOST_AUTO_TEST_CASE(test_parse_basic_multiline_string)
//XXX ifdef windows platform
const std::string source("\"\"\"\nRoses are red\nViolets are blue\"\"\"");
const std::string expected("Roses are red\nViolets are blue");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("\"\"\"\nThe quick brown \\\n\n fox jumps over \\\n the lazy dog.\"\"\"");
const std::string expected("The quick brown fox jumps over the lazy dog.");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("\"\"\"\nThe quick brown \\\n fox jumps over \\\n the lazy dog.\\\n \"\"\"");
const std::string expected("The quick brown fox jumps over the lazy dog.");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -83,38 +83,38 @@ BOOST_AUTO_TEST_CASE(test_parse_literal_inline_string)
{
const std::string source("'C:\\Users\\nodejs\\templates'");
const std::string expected("C:\\Users\\nodejs\\templates");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("'\\\\ServerX\\admin$\\system32\\'");
const std::string expected("\\\\ServerX\\admin$\\system32\\");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("'Tom \"Dubs\" Preston-Werner'");
const std::string expected("Tom \"Dubs\" Preston-Werner");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("'<\\i\\c*\\s*>'");
const std::string expected("<\\i\\c*\\s*>");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -127,22 +127,22 @@ BOOST_AUTO_TEST_CASE(test_parse_literal_multiline_string)
{
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 auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("'''\nThe first newline is \ntrimmed in raw strings.\n All other whitespace\n is preserved.'''");
const std::string expected("The first newline is \ntrimmed in raw strings.\n All other whitespace\n is preserved.");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -155,38 +155,38 @@ BOOST_AUTO_TEST_CASE(test_parse_string)
{
const std::string source("\"string\"");
const std::string expected("string");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("\"\"\"string\"\"\"");
const std::string expected("string");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("'string'");
const std::string expected("string");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("'''string'''");
const std::string expected("string");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -199,38 +199,38 @@ BOOST_AUTO_TEST_CASE(test_integer)
{
const std::string source("42");
const toml::Integer expected(42);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("+42");
const toml::Integer expected(42);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("-42");
const toml::Integer expected(-42);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("-4_2");
const toml::Integer expected(-42);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -243,60 +243,60 @@ BOOST_AUTO_TEST_CASE(test_float)
{
const std::string source("42.0");
const toml::Float expected(42.0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("+42.0");
const toml::Float expected(42.0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("-42.0");
const toml::Float expected(-42.0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("-4_2.0");
const toml::Float expected(-42.0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("-42e0");
const toml::Float expected(-42.0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("-42.0e0");
const toml::Float expected(-42.0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
{
const std::string source("42");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -309,22 +309,22 @@ BOOST_AUTO_TEST_CASE(test_parse_boolean)
{
const std::string source("true");
const toml::Boolean expected(true);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("false");
const toml::Boolean expected(false);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("dummy");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -339,30 +339,30 @@ BOOST_AUTO_TEST_CASE(test_parse_local_time)
{
const std::string source("12:34:56");
const toml::Datetime expected(12, 34, 56, 0, 0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("12:34:56.7");
const toml::Datetime expected(12, 34, 56, 700, 0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("12:34:56.7891");
const toml::Datetime expected(12, 34, 56, 789, 100);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("10");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -375,14 +375,14 @@ BOOST_AUTO_TEST_CASE(test_parse_local_date)
{
const std::string source("1979-09-27");
const toml::Datetime expected(1979, 9, 27);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("10");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -395,22 +395,22 @@ 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);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("1000-11-11");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -423,56 +423,56 @@ BOOST_AUTO_TEST_CASE(test_parse_offset_date_time)
{
const std::string source("1979-09-27T12:34:56Z");
const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("1979-09-27T12:34:56.789000Z");
const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 789, 0, 0, 0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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 auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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 auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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 auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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 auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("1000-11-11");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -485,38 +485,38 @@ BOOST_AUTO_TEST_CASE(test_parse_datetime)
{
const std::string source("1979-09-27T12:34:56Z");
const toml::Datetime expected(1979, 9, 27, 12, 34, 56, 0, 0, 0, 0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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 auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("1979-09-27");
const toml::Datetime expected(1979, 9, 27);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("12:34:56");
const toml::Datetime expected(12, 34, 56, 0, 0);
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK_EQUAL(result.first.get(), expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("12");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -530,98 +530,98 @@ BOOST_AUTO_TEST_CASE(test_parse_array)
{
const std::string source("[1,2,3]");
const toml::Array expected{1, 2, 3};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[1, 2, 3]");
const toml::Array expected{1, 2, 3};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[ 1,2,3 ]");
const toml::Array expected{1, 2, 3};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[ 1 , 2 , 3 ]");
const toml::Array expected{1, 2, 3};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[ 1 \n,#comment\n 2 ,\n 3\n ]");
const toml::Array expected{1, 2, 3};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[ # empty array\n ]");
const toml::Array expected{};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[ \"] \", ' # ', \n']', # ] \n]");
const toml::Array expected{"] ", " # ", "]"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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 auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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 auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[ [1,2,3] , ['a', 'b', 'c'] ]");
const toml::Array expected{{1,2,3}, {"a", "b", "c"}};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[dummy]");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -635,26 +635,26 @@ BOOST_AUTO_TEST_CASE(test_parse_inline_table)
{
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());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
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());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
@@ -663,14 +663,14 @@ BOOST_AUTO_TEST_CASE(test_parse_inline_table)
{"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());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("{dummy}");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(!result.first.ok());
BOOST_CHECK(result.second == source.begin());
}
@@ -683,34 +683,34 @@ BOOST_AUTO_TEST_CASE(test_parse_barekey)
{
const std::string source("hoge");
const toml::key expected("hoge");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("bare-key");
const toml::key expected("bare-key");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("bare_key");
const toml::key expected("bare_key");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("42");
const toml::key expected("42");
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
}
@@ -723,75 +723,75 @@ BOOST_AUTO_TEST_CASE(test_key_value_pair)
{
const std::string source("key=1");
const std::pair<toml::key, toml::value> expected{"key", 1};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key =\t1");
const std::pair<toml::key, toml::value> expected{"key", 1};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key = true");
const std::pair<toml::key, toml::value> expected{"key", true};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key = -42");
const std::pair<toml::key, toml::value> expected{"key", -42};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key = -42.0");
const std::pair<toml::key, toml::value> expected{"key", -42.};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key = \"string\"");
const std::pair<toml::key, toml::value> expected{"key", "string"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key = 1901-01-01T00:00:00");
const std::pair<toml::key, toml::value> expected{"key", toml::Datetime(1901, 1,1,0,0,0,0,0)};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key = [1,2,3]");
const std::pair<toml::key, toml::value> expected{"key", {1,2,3}};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("key = {foo=1,bar=2.0,baz='3'}");
const std::pair<toml::key, toml::value> expected{"key",
{{"foo", 1}, {"bar", 2.0}, {"baz", "3"}}};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
}
@@ -802,42 +802,42 @@ BOOST_AUTO_TEST_CASE(test_table_definition)
{
const std::string source("[foo]");
const std::vector<toml::key> expected{"foo"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[foo.bar.baz]");
const std::vector<toml::key> expected{"foo", "bar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[foo . bar. baz]");
const std::vector<toml::key> expected{"foo", "bar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[foo . \"bar\" . baz]");
const std::vector<toml::key> expected{"foo", "bar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[foo . \"b\\tar\" . baz]");
const std::vector<toml::key> expected{"foo", "b\tar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
}
@@ -848,42 +848,42 @@ BOOST_AUTO_TEST_CASE(test_array_of_table_definition)
{
const std::string source("[[foo]]");
const std::vector<toml::key> expected{"foo"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[[foo.bar.baz]]");
const std::vector<toml::key> expected{"foo", "bar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[[foo . bar. baz]]");
const std::vector<toml::key> expected{"foo", "bar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[[foo . \"bar\" . baz]]");
const std::vector<toml::key> expected{"foo", "bar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
{
const std::string source("[[foo . \"b\\tar\" . baz]]");
const std::vector<toml::key> expected{"foo", "b\tar", "baz"};
const auto result = parser::invoke(source.cbegin());
const auto result = parser::invoke(source.cbegin(), source.cend());
BOOST_CHECK(result.first.ok());
BOOST_CHECK(result.first.get() == expected);
BOOST_CHECK(result.second == acceptor::invoke(source.begin()));
BOOST_CHECK(result.second == acceptor::invoke(source.begin(), source.end()));
}
}

78
toml/acceptor.hpp
View File

@@ -17,9 +17,9 @@ struct is_charactor
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
constexpr static Iterator invoke(Iterator iter)
constexpr static Iterator invoke(Iterator iter, Iterator end)
{
return *iter == c ? std::next(iter) : iter;
return iter == end ? iter : *iter == c ? std::next(iter) : iter;
}
};
@@ -34,9 +34,10 @@ struct is_in_range
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
constexpr static Iterator invoke(Iterator iter)
constexpr static Iterator invoke(Iterator iter, Iterator end)
{
return (lower <= *iter && *iter <= upper) ? std::next(iter) : iter;
return iter == end ? iter :
(lower <= *iter && *iter <= upper) ? std::next(iter) : iter;
}
};
@@ -51,10 +52,11 @@ struct is_one_of
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
const Iterator tmp = headT::invoke(iter);
return (tmp != iter) ? tmp : is_one_of<condT...>::invoke(iter);
if(iter == end) return iter;
const Iterator tmp = headT::invoke(iter, end);
return (tmp != iter) ? tmp : is_one_of<condT...>::invoke(iter, end);
}
};
template<typename tailT>
@@ -65,9 +67,10 @@ struct is_one_of<tailT>
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
const Iterator tmp = tailT::invoke(iter);
if(iter == end) return iter;
const Iterator tmp = tailT::invoke(iter, end);
return (tmp != iter) ? tmp : iter;
}
};
@@ -81,9 +84,9 @@ struct is_ignorable
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
const Iterator tmp = condT::invoke(iter);
const Iterator tmp = condT::invoke(iter, end);
return (tmp != iter) ? tmp : iter;
}
};
@@ -106,11 +109,12 @@ struct is_chain_of_impl
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter, Iterator rollback)
static Iterator invoke(Iterator iter, Iterator end, Iterator rollback)
{
const Iterator tmp = headT::invoke(iter);
if(iter == end) return iter;
const Iterator tmp = headT::invoke(iter, end);
return (tmp == iter && !ignorable) ? rollback :
is_chain_of_impl<condT...>::invoke(tmp, rollback);
is_chain_of_impl<condT...>::invoke(tmp, end, rollback);
}
};
@@ -123,9 +127,10 @@ struct is_chain_of_impl<tailT>
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter, Iterator rollback)
static Iterator invoke(Iterator iter, Iterator end, Iterator rollback)
{
const Iterator tmp = tailT::invoke(iter);
if(iter == end) return iter;
const Iterator tmp = tailT::invoke(iter, end);
return (tmp == iter) ? (ignorable ? iter : rollback) : tmp;
}
};
@@ -138,9 +143,9 @@ struct is_chain_of
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
return is_chain_of_impl<headT, condT...>::invoke(iter, iter);
return is_chain_of_impl<headT, condT...>::invoke(iter, end, iter);
}
};
@@ -154,13 +159,14 @@ struct is_repeat_of
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
if(iter == end) return iter;
const Iterator rollback = iter;
Iterator tmp;
for(auto i=0ul; i<N; ++i)
{
tmp = condT::invoke(iter);
tmp = condT::invoke(iter, end);
if(tmp == iter) return rollback;
iter = tmp;
}
@@ -176,13 +182,14 @@ struct is_repeat_of<condT, 0>
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
Iterator tmp = condT::invoke(iter);
if(iter == end) return iter;
Iterator tmp = condT::invoke(iter, end);
while(tmp != iter)
{
iter = tmp;
tmp = condT::invoke(iter);
tmp = condT::invoke(iter, end);
}
return iter;
}
@@ -199,10 +206,11 @@ struct is_none_of
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
const Iterator tmp = headT::invoke(iter);
return (tmp != iter) ? iter : is_none_of<tailT...>::invoke(iter);
if(iter == end) return iter;
const Iterator tmp = headT::invoke(iter, end);
return (tmp != iter) ? iter : is_none_of<tailT...>::invoke(iter, end);
}
};
@@ -214,9 +222,10 @@ struct is_none_of<tailT>
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
const Iterator tmp = tailT::invoke(iter);
if(iter == end) return iter;
const Iterator tmp = tailT::invoke(iter, end);
return (tmp != iter) ? iter : std::next(iter);
}
};
@@ -232,9 +241,10 @@ struct is_not_but
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
return (iter != notT::invoke(iter)) ? iter : butT::invoke(iter);
if(iter == end) return iter;
return (iter != notT::invoke(iter, end)) ? iter : butT::invoke(iter, end);
}
};
@@ -582,7 +592,7 @@ struct is_array
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
return is_one_of<
is_fixed_type_array<charT, is_boolean<charT>>,
@@ -592,7 +602,7 @@ struct is_array
is_fixed_type_array<charT, is_datetime<charT>>,
is_fixed_type_array<charT, is_array<charT>>,
is_fixed_type_array<charT, is_inline_table<charT>>
>::invoke(iter);
>::invoke(iter, end);
}
};
@@ -604,7 +614,7 @@ struct is_inline_table
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static Iterator invoke(Iterator iter)
static Iterator invoke(Iterator iter, Iterator end)
{
typedef is_one_of<is_fundamental_type<charT>,
is_array<charT>, is_inline_table<charT>> is_component;
@@ -643,7 +653,7 @@ struct is_inline_table
is_any_num_of_ws<charT>,
is_charactor<charT, '}'>
> entity;
return entity::invoke(iter);
return entity::invoke(iter, end);
}
};

307
toml/parser.hpp
View File

@@ -63,9 +63,10 @@ struct parse_escape_sequence
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator> invoke(Iterator iter, Iterator end)
{
if(*iter != '\\') return std::make_pair(result_type{}, iter);
if(iter == end || *iter != '\\')
return std::make_pair(result_type{}, iter);
++iter;
switch(*iter)
{
@@ -77,11 +78,19 @@ struct parse_escape_sequence
case 'f' : return std::make_pair(string_type("\f"), std::next(iter));
case 'r' : return std::make_pair(string_type("\r"), std::next(iter));
case 'u' :
{
if(std::distance(iter, end) < 5)
throw syntax_error("invalid escape sequence");
return std::make_pair(utf8_to_char(make_codepoint(
string_type(iter+1, iter+5))), iter+5);
}
case 'U':
{
if(std::distance(iter, end) < 8)
throw syntax_error("invalid escape sequence");
return std::make_pair(utf8_to_char(make_codepoint(
string_type(iter+1, iter+9))), iter+9);
}
default: throw syntax_error("unkwnon escape sequence");
}
}
@@ -131,9 +140,11 @@ struct parse_basic_inline_string
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_basic_inline_string<value_type>::invoke(iter);
const Iterator end =
is_basic_inline_string<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
if(std::distance(iter, end) < 2)
throw internal_error("is_basic_inline_string");
@@ -145,8 +156,9 @@ struct parse_basic_inline_string
{
if(*iter == '\\')
{
auto r = parse_escape_sequence::invoke(iter);
if(!r.first.ok()) throw internal_error("parse_basic_inline_string");
auto r = parse_escape_sequence::invoke(iter, last);
if(!r.first.ok())
throw internal_error("parse_basic_inline_string");
result += r.first.move();
iter = r.second;
}
@@ -174,9 +186,11 @@ struct parse_basic_multiline_string
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_basic_multiline_string<value_type>::invoke(iter);
const Iterator end =
is_basic_multiline_string<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
if(std::distance(iter, end) < 6)
throw internal_error("is_basic_inline_string");
@@ -184,19 +198,20 @@ struct parse_basic_multiline_string
toml::String result; result.reserve(std::distance(iter, end)-6);
std::advance(iter, 3);
const Iterator last = end - 3;
iter = is_newline<value_type>::invoke(iter); // trim first newline if exists
iter = is_newline<value_type>::invoke(iter, last);
while(iter != last)
{
if(*iter == '\\')
{
if(is_line_ending_backslash::invoke(iter) != iter)
if(is_line_ending_backslash::invoke(iter, last) != iter)
{
iter = ws_nl_after_backslash_remover::invoke(std::next(iter));
iter = ws_nl_after_backslash_remover::invoke(std::next(iter), last);
}
else
{
auto r = parse_escape_sequence::invoke(iter);
if(!r.first.ok()) throw internal_error("parse_basic_inline_string");
auto r = parse_escape_sequence::invoke(iter, last);
if(!r.first.ok())
throw internal_error("parse_basic_inline_string");
result += r.first.move();
iter = r.second;
}
@@ -219,9 +234,11 @@ struct parse_literal_inline_string
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_literal_inline_string<value_type>::invoke(iter);
const Iterator end =
is_literal_inline_string<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
if(std::distance(iter, end) < 2)
throw internal_error("is_literal_inline_string");
@@ -251,9 +268,11 @@ struct parse_literal_multiline_string
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_literal_multiline_string<value_type>::invoke(iter);
const Iterator end =
is_literal_multiline_string<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
if(std::distance(iter, end) < 6)
throw internal_error("is_literal_multiline_string");
@@ -261,7 +280,7 @@ struct parse_literal_multiline_string
toml::String result; result.reserve(std::distance(iter, end)-6);
std::advance(iter, 3);
const Iterator last = end - 3;
iter = is_newline<value_type>::invoke(iter); // trim first newline if exist
iter = is_newline<value_type>::invoke(iter, last); // trim first newline if exist
while(iter != last)
{
result.push_back(*iter);
@@ -279,16 +298,17 @@ struct parse_string
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
std::pair<result_type, Iterator> result;
if((result = parse_basic_inline_string::invoke(iter)).first.ok())
if((result = parse_basic_inline_string::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_basic_multiline_string::invoke(iter)).first.ok())
else if((result = parse_basic_multiline_string::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_literal_inline_string::invoke(iter)).first.ok())
else if((result = parse_literal_inline_string::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_literal_multiline_string::invoke(iter)).first.ok())
else if((result = parse_literal_multiline_string::invoke(iter, range_end)).first.ok())
return result;
else
return std::make_pair(result_type{}, iter);
@@ -304,9 +324,9 @@ struct parse_integer
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator> invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_integer<value_type>::invoke(iter);
const Iterator end = is_integer<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
string_type result; result.resize(std::distance(iter, end));
@@ -324,9 +344,10 @@ struct parse_float
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_float<value_type>::invoke(iter);
const Iterator end = is_float<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
string_type result; result.resize(std::distance(iter, end));
@@ -351,9 +372,10 @@ struct parse_boolean
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_boolean<value_type>::invoke(iter);
const Iterator end = is_boolean<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
return std::make_pair((std::distance(iter, end) == 4), end);
}
@@ -373,18 +395,19 @@ struct parse_local_time
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_local_time<value_type>::invoke(iter);
const Iterator end = is_local_time<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
toml::Datetime result;
result.hour = std::stoi(string_type(iter, nums<2>::invoke(iter)));
iter = delim::invoke(nums<2>::invoke(iter));
result.minute = std::stoi(string_type(iter, nums<2>::invoke(iter)));
iter = delim::invoke(nums<2>::invoke(iter));
result.second = std::stoi(string_type(iter, nums<2>::invoke(iter)));
iter = fract::invoke(nums<2>::invoke(iter));
result.hour = std::stoi(string_type(iter, nums<2>::invoke(iter, end)));
iter = delim::invoke(nums<2>::invoke(iter, end), end);
result.minute = std::stoi(string_type(iter, nums<2>::invoke(iter, end)));
iter = delim::invoke(nums<2>::invoke(iter, end), end);
result.second = std::stoi(string_type(iter, nums<2>::invoke(iter, end)));
iter = fract::invoke(nums<2>::invoke(iter, end), end);
if(iter == end)
{
result.millisecond = 0.0;
@@ -432,17 +455,18 @@ struct parse_local_date
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_local_date<value_type>::invoke(iter);
const Iterator end = is_local_date<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
toml::Datetime result;
result.year = std::stoi(string_type(iter, nums<4>::invoke(iter)));
iter = delim::invoke(nums<4>::invoke(iter));
result.month = std::stoi(string_type(iter, nums<2>::invoke(iter)));
iter = delim::invoke(nums<2>::invoke(iter));
result.day = std::stoi(string_type(iter, nums<2>::invoke(iter)));
result.year = std::stoi(string_type(iter, nums<4>::invoke(iter, end)));
iter = delim::invoke(nums<4>::invoke(iter, end), end);
result.month = std::stoi(string_type(iter, nums<2>::invoke(iter, end)));
iter = delim::invoke(nums<2>::invoke(iter, end), end);
result.day = std::stoi(string_type(iter, nums<2>::invoke(iter, end)));
result.offset_hour = toml::Datetime::nooffset;
result.offset_minute = toml::Datetime::nooffset;
@@ -467,17 +491,19 @@ struct parse_local_date_time
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_local_date_time<value_type>::invoke(iter);
const Iterator end =
is_local_date_time<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
auto ld = parse_local_date::invoke(iter);
auto ld = parse_local_date::invoke(iter, end);
if(!ld.first.ok()) throw syntax_error("invalid local datetime");
toml::Datetime result(ld.first.move());
iter = delim::invoke(ld.second);// 'T'
iter = delim::invoke(ld.second, end);// 'T'
const auto time = parse_local_time::invoke(iter);
const auto time = parse_local_time::invoke(iter, end);
result.hour = time.first.get().hour;
result.minute = time.first.get().minute;
result.second = time.first.get().second;
@@ -501,12 +527,14 @@ struct parse_offset_date_time
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_offset_date_time<value_type>::invoke(iter);
const Iterator end =
is_offset_date_time<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
auto ldt = parse_local_date_time::invoke(iter);
auto ldt = parse_local_date_time::invoke(iter, end);
if(!ldt.first.ok()) throw syntax_error("invalid offset datetime");
toml::Datetime result(ldt.first.move());
iter = ldt.second;
@@ -522,10 +550,10 @@ struct parse_offset_date_time
const int sign = (*iter == '-') ? -1 : 1;
++iter;
result.offset_hour = sign *
std::stoi(string_type(iter, nums<2>::invoke(iter)));
iter = delim::invoke(nums<2>::invoke(iter));
std::stoi(string_type(iter, nums<2>::invoke(iter, end)));
iter = delim::invoke(nums<2>::invoke(iter, end), end);
result.offset_minute = sign *
std::stoi(string_type(iter, nums<2>::invoke(iter)));
std::stoi(string_type(iter, nums<2>::invoke(iter, end)));
}
return std::make_pair(result, end);
}
@@ -539,16 +567,17 @@ struct parse_datetime
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
std::pair<result_type, Iterator> result;
if((result = parse_offset_date_time::invoke(iter)).first.ok())
if((result = parse_offset_date_time::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_local_date_time::invoke(iter)).first.ok())
else if((result = parse_local_date_time::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_local_date::invoke(iter)).first.ok())
else if((result = parse_local_date::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_local_time::invoke(iter)).first.ok())
else if((result = parse_local_time::invoke(iter, range_end)).first.ok())
return result;
else
return std::make_pair(result_type{}, iter);
@@ -567,25 +596,26 @@ struct parse_fixed_type_array
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator> invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_fixed_type_array<value_type, acceptorT>::invoke(iter);
const Iterator end =
is_fixed_type_array<value_type, acceptorT>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
toml::Array result;
const Iterator last = std::prev(end);
iter = skippable::invoke(std::next(iter));
iter = skippable::invoke(std::next(iter), last);
while(iter != last)
{
const Iterator tmp = acceptor_type::invoke(iter);
const Iterator tmp = acceptor_type::invoke(iter, last);
if(tmp == iter) throw syntax_error("parse_array");
auto next = parser_type::invoke(iter);
auto next = parser_type::invoke(iter, last);
if(!next.first.ok()) throw syntax_error("parse_array");
result.emplace_back(next.first.move());
iter = tmp;
iter = skippable::invoke(iter);
iter = is_charactor<value_type, ','>::invoke(iter);
iter = skippable::invoke(iter);
iter = skippable::invoke(iter, last);
iter = is_charactor<value_type, ','>::invoke(iter, last);
iter = skippable::invoke(iter, last);
}
return std::make_pair(result, end);
}
@@ -605,31 +635,32 @@ struct parse_array
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
if(iter == is_array<value_type>::invoke(iter))
if(iter == is_array<value_type>::invoke(iter, range_end))
return std::make_pair(result_type{}, iter);
std::pair<result_type, Iterator> result;
if((result = parse_fixed_type_array<is_boolean<value_type>,
parse_boolean>::invoke(iter)).first.ok()) return result;
parse_boolean>::invoke(iter, range_end)).first.ok()) return result;
else if((result = parse_fixed_type_array<is_string<value_type>,
parse_string>::invoke(iter)).first.ok()) return result;
parse_string>::invoke(iter, range_end)).first.ok()) return result;
else if((result = parse_fixed_type_array<is_datetime<value_type>,
parse_datetime>::invoke(iter)).first.ok()) return result;
parse_datetime>::invoke(iter, range_end)).first.ok()) return result;
else if((result = parse_fixed_type_array<is_float<value_type>,
parse_float>::invoke(iter)).first.ok()) return result;
parse_float>::invoke(iter, range_end)).first.ok()) return result;
else if((result = parse_fixed_type_array<is_integer<value_type>,
parse_integer>::invoke(iter)).first.ok()) return result;
parse_integer>::invoke(iter, range_end)).first.ok()) return result;
else if((result = parse_fixed_type_array<is_array<value_type>,
parse_array<value_type>>::invoke(iter)).first.ok()) return result;
parse_array<value_type>>::invoke(iter, range_end)).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())
parse_inline_table<value_type>>::invoke(iter, range_end)).first.ok())
return result;
else if(skippable::invoke(std::next(iter)) == // empty
std::prev(is_array<value_type>::invoke(iter))
else if(skippable::invoke(std::next(iter), range_end) == // empty
std::prev(is_array<value_type>::invoke(iter, range_end))
) return std::make_pair(
toml::Array{}, is_array<value_type>::invoke(iter));
toml::Array{}, is_array<value_type>::invoke(iter, range_end));
else throw syntax_error("no valid array here");
}
};
@@ -644,22 +675,23 @@ struct parse_value
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
std::pair<result_type, Iterator> result;
if((result = parse_boolean::invoke(iter)).first.ok())
if((result = parse_boolean::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_string::invoke(iter)).first.ok())
else if((result = parse_string::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_datetime::invoke(iter)).first.ok())
else if((result = parse_datetime::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_float::invoke(iter)).first.ok())
else if((result = parse_float::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_integer::invoke(iter)).first.ok())
else if((result = parse_integer::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_array<value_type>::invoke(iter)).first.ok())
else if((result = parse_array<value_type>::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_inline_table<value_type>::invoke(iter)).first.ok())
else if((result = parse_inline_table<value_type>::invoke(iter, range_end)).first.ok())
return result;
else
return std::make_pair(result_type{}, iter);
@@ -674,9 +706,10 @@ struct parse_barekey
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_barekey<value_type>::invoke(iter);
const Iterator end = is_barekey<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
return std::make_pair(toml::key(iter, end), end);
}
@@ -690,12 +723,13 @@ struct parse_key
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
std::pair<result_type, Iterator> result;
if((result = parse_barekey::invoke(iter)).first.ok())
if((result = parse_barekey::invoke(iter, range_end)).first.ok())
return result;
else if((result = parse_string::invoke(iter)).first.ok())
else if((result = parse_string::invoke(iter, range_end)).first.ok())
return result;
else return std::make_pair(result_type{}, iter);
}
@@ -711,16 +745,17 @@ struct parse_key_value_pair
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
auto tmp_key = parse_key::invoke(iter);
auto tmp_key = parse_key::invoke(iter, range_end);
if(!tmp_key.first.ok())
return std::make_pair(result_type{}, iter);
iter = is_any_num_of_ws<charT>::invoke(tmp_key.second);
iter = is_any_num_of_ws<charT>::invoke(tmp_key.second, range_end);
if(*iter != '=') throw syntax_error("invalid key value pair");
iter = is_any_num_of_ws<charT>::invoke(std::next(iter));
iter = is_any_num_of_ws<charT>::invoke(std::next(iter), range_end);
auto tmp_value = parse_value<toml::charactor>::invoke(iter);
auto tmp_value = parse_value<toml::charactor>::invoke(iter, range_end);
if(!tmp_value.first.ok())
throw syntax_error("invalid key value pair");
@@ -728,7 +763,7 @@ struct parse_key_value_pair
return std::make_pair(std::make_pair(
tmp_key.first.move(), tmp_value.first.move()),
is_any_num_of_ws<charT>::invoke(tmp_value.second));
is_any_num_of_ws<charT>::invoke(tmp_value.second, range_end));
}
};
@@ -742,26 +777,27 @@ struct parse_inline_table
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_inline_table<value_type>::invoke(iter);
const Iterator end = is_inline_table<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
iter = is_any_num_of_ws<value_type>::invoke(std::next(iter));
iter = is_any_num_of_ws<value_type>::invoke(std::next(iter), range_end);
const Iterator last = std::prev(end);
toml::Table result;
while(iter != last)
{
auto tmp = parse_key_value_pair<value_type>::invoke(iter);
auto tmp = parse_key_value_pair<value_type>::invoke(iter, last);
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);
iter = is_any_num_of_ws<value_type>::invoke(iter, last);
iter = is_charactor<value_type, ','>::invoke(iter, last);
iter = is_any_num_of_ws<value_type>::invoke(iter, last);
}
return std::make_pair(result, end);
}
@@ -775,32 +811,34 @@ struct parse_table_definition
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_table_definition<value_type>::invoke(iter);
const Iterator end =
is_table_definition<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
std::vector<toml::key> result;
result.reserve(std::count(iter, end, '.')+1);
const Iterator last = std::prev(end);
iter = is_any_num_of_ws<value_type>::invoke(iter);
iter = is_any_num_of_ws<value_type>::invoke(std::next(iter));
iter = is_any_num_of_ws<value_type>::invoke(iter, last);
iter = is_any_num_of_ws<value_type>::invoke(std::next(iter), last);
auto tmp = parse_key::invoke(iter);
auto tmp = parse_key::invoke(iter, last);
if(!tmp.first.ok()) throw syntax_error("table definition");
result.emplace_back(tmp.first.move());
iter = is_any_num_of_ws<value_type>::invoke(tmp.second);
iter = is_any_num_of_ws<value_type>::invoke(tmp.second, last);
while(iter != last)
{
iter = is_charactor<value_type, '.'>::invoke(iter);
iter = is_any_num_of_ws<value_type>::invoke(iter);
iter = is_charactor<value_type, '.'>::invoke(iter, last);
iter = is_any_num_of_ws<value_type>::invoke(iter, last);
tmp = parse_key::invoke(iter);
tmp = parse_key::invoke(iter, last);
if(!tmp.first.ok()) throw syntax_error("table definition");
result.emplace_back(tmp.first.move());
iter = is_any_num_of_ws<value_type>::invoke(tmp.second);
iter = is_any_num_of_ws<value_type>::invoke(tmp.second, last);
}
return std::make_pair(result, end);
}
@@ -814,32 +852,37 @@ struct parse_array_of_table_definition
template<typename Iterator, class = typename std::enable_if<
std::is_same<typename std::iterator_traits<Iterator>::value_type,
value_type>::value>::type>
static std::pair<result_type, Iterator> invoke(Iterator iter)
static std::pair<result_type, Iterator>
invoke(Iterator iter, Iterator range_end)
{
const Iterator end = is_array_of_table_definition<value_type>::invoke(iter);
const Iterator end =
is_array_of_table_definition<value_type>::invoke(iter, range_end);
if(iter == end) return std::make_pair(result_type{}, iter);
if(std::distance(iter, end) < 5)
throw syntax_error("invalid array_of_table definition");
std::vector<toml::key> result;
result.reserve(std::count(iter, end, '.')+1);
const Iterator last = end - 2;
iter = is_any_num_of_ws<value_type>::invoke(iter) + 2;
iter = is_any_num_of_ws<value_type>::invoke(iter);
iter = is_any_num_of_ws<value_type>::invoke(iter, last) + 2;
iter = is_any_num_of_ws<value_type>::invoke(iter, last);
auto tmp = parse_key::invoke(iter);
auto tmp = parse_key::invoke(iter, last);
if(!tmp.first.ok()) throw syntax_error("array of table definition");
result.emplace_back(tmp.first.move());
iter = is_any_num_of_ws<value_type>::invoke(tmp.second);
iter = is_any_num_of_ws<value_type>::invoke(tmp.second, last);
while(iter != last)
{
iter = is_charactor<value_type, '.'>::invoke(iter);
iter = is_any_num_of_ws<value_type>::invoke(iter);
iter = is_charactor<value_type, '.'>::invoke(iter, last);
iter = is_any_num_of_ws<value_type>::invoke(iter, last);
tmp = parse_key::invoke(iter);
tmp = parse_key::invoke(iter, last);
if(!tmp.first.ok()) throw syntax_error("array of table definition");
result.emplace_back(tmp.first.move());
iter = is_any_num_of_ws<value_type>::invoke(tmp.second);
iter = is_any_num_of_ws<value_type>::invoke(tmp.second, last);
}
return std::make_pair(result, end);
}
@@ -864,14 +907,14 @@ struct parse_data
{
iter = skip_empty(iter, end);
std::pair<detail::result<std::vector<toml::key>>, Iterator> tabname;
if((tabname = parse_table_definition::invoke(iter)).first.ok())
if((tabname = parse_table_definition::invoke(iter, end)).first.ok())
{
auto contents = parse_table_contents(tabname.second, end);
push_table(result, std::move(contents.first),
tabname.first.get().begin(), tabname.first.get().end());
iter = contents.second;
}
else if((tabname = parse_array_of_table_definition::invoke(iter)).first.ok())
else if((tabname = parse_array_of_table_definition::invoke(iter, end)).first.ok())
{
auto contents = parse_table_contents(tabname.second, end);
push_array_of_table(result, std::move(contents.first),
@@ -895,10 +938,10 @@ struct parse_data
if(*iter == '#')
{
while(iter != end &&
iter == is_newline<value_type>::invoke(iter)){++iter;}
iter == is_newline<value_type>::invoke(iter, end)){++iter;}
}
else if(iter == is_newline<value_type>::invoke(iter) &&
iter == is_whitespace<value_type>::invoke(iter))
else if(iter == is_newline<value_type>::invoke(iter, end) &&
iter == is_whitespace<value_type>::invoke(iter, end))
{
return iter;
}
@@ -920,7 +963,7 @@ struct parse_data
iter = skip_empty(iter, end);
while(iter != end)
{
auto kv = parse_key_value_pair<value_type>::invoke(iter);
auto kv = parse_key_value_pair<value_type>::invoke(iter, end);
if(!kv.first.ok()) return std::make_pair(table, iter);
table.emplace(kv.first.move());