diff --git a/tests/test_acceptor.cpp b/tests/test_acceptor.cpp
index cae682d..c9d154b 100644
--- a/tests/test_acceptor.cpp
+++ b/tests/test_acceptor.cpp
@@ -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());
     }
 }
diff --git a/tests/test_parser.cpp b/tests/test_parser.cpp
index 0f2f0aa..6b66b2c 100644
--- a/tests/test_parser.cpp
+++ b/tests/test_parser.cpp
@@ -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()));
     }
 }
 
diff --git a/toml/acceptor.hpp b/toml/acceptor.hpp
index 5033e40..286e22a 100644
--- a/toml/acceptor.hpp
+++ b/toml/acceptor.hpp
@@ -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);
     }
 };
 
diff --git a/toml/parser.hpp b/toml/parser.hpp
index bba80fd..6e4fb48 100644
--- a/toml/parser.hpp
+++ b/toml/parser.hpp
@@ -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());