Merge pull request #32 from ToruNiina/allow-deeper-table-before

Allow deeper table before
Merge branch 'master' into allow-deeper-table-before
2025-12-16 03:08:52 +08:00 · 2019-03-06 12:03:14 +09:00 · 2019-03-05 23:27:11 +09:00 · 2019-03-05 23:25:25 +09:00 · 2019-03-04 15:01:28 +09:00 · 2019-03-03 18:56:45 +09:00
18 changed files with 1397 additions and 361 deletions
--- a/PROPOSAL.md
+++ b/PROPOSAL.md
@@ -1,59 +0,0 @@
-
-### encoding user's data
-
-You can encode your data to toml format.
-
-```cpp
-const toml::value integer(1);
-const toml::value array{3.1, 3.14, 3.141, 3.1415};
-const toml::value table{{"answer", 42}, {"pi", 3.14}, {"string", "foobar"}};
-
-std::cout << toml::format("integer", integer) << std::endl;
-std::cout << toml::format("array",   array)   << std::endl;
-std::cout << toml::format("table",   table)   << std::endl;
-```
-
-this program will output as below.
-
-```toml
-integer = 1
-array = [3.1, 3.14, 3.141, 3.1415]
-[table]
-answer = 42
-pi = 3.14
-string = "foobar"
-```
-
-Without key name, you can make string formatted as toml.
-
-```cpp
-const std::string integer_ = toml::format(integer); // "1"
-const std::string array_   = toml::format(array);   // "[3.1, 3.14, 3.141, 3.1415]"
-const std::string table_   = toml::format(table);   // "answer = 42\npi=3.14\nstring=foobar"
-```
-
-### inlinize
-
-You can make `toml::Table` inline.
-
-```cpp
-const toml::value table{{"answer", 42}, {"pi", 3.14}, {"string", "foobar"}};
-// if the inline-table format length is less than 80, the table will be inlined
-std::cout << toml::format("table", table, toml::make_inline(80)) << std::endl;
-// In any case, the table will be inlined.
-std::cout << toml::format("table", table, toml::forceinline) << std::endl;
-```
-
-```toml
-table = {answer = 42, pi = 3.14, string = "foobar"}
-```
-
-And there are some stream manipulators for toml format.
-
-```cpp
-const toml::value table{{"answer", 42}, {"pi", 3.14}, {"string", "foobar"}};
-// if the inline-table format length is less than 80, the table will be inlined
-std::cout << toml::make_inline(80) << table << std::endl;
-// In any case, the table will be inlined.
-std::cout << toml::forceinline << table << std::endl;
-```
--- a/README.md
+++ b/README.md
@@ -2,15 +2,20 @@ toml11
 ======

 [![Build Status](https://travis-ci.org/ToruNiina/toml11.svg?branch=master)](https://travis-ci.org/ToruNiina/toml11)
-[![Build status](https://ci.appveyor.com/api/projects/status/m2n08a926asvg5mg?svg=true)](https://ci.appveyor.com/project/ToruNiina/toml11)
-[![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
+[![Build status](https://ci.appveyor.com/api/projects/status/m2n08a926asvg5mg/branch/master?svg=true)](https://ci.appveyor.com/project/ToruNiina/toml11/branch/master)
+[![Version](https://img.shields.io/github/release/ToruNiina/toml11.svg?style=flat)](https://github.com/ToruNiina/toml11/releases)
+[![License](https://img.shields.io/github/license/ToruNiina/toml11.svg?style=flat)](LICENSE)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1209136.svg)](https://doi.org/10.5281/zenodo.1209136)

-c++11 header-only toml parser depending only on c++ standard library.
+C++11 header-only toml parser depending only on C++ standard library.

-compatible to the latest version of [TOML v0.5.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.5.0.md) after version 2.0.0.
+compatible to the latest version of
+[TOML v0.5.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.5.0.md)
+after version 2.0.0.

-Are you looking for pre-C++11 compatible toml parser? Try [Boost.toml](https://github.com/ToruNiina/Boost.toml)! It has almost the same functionality as this library and works with C++98 & Boost.
+Are you looking for pre-C++11 compatible toml parser?
+Try [Boost.toml](https://github.com/ToruNiina/Boost.toml)!
+It has almost the same functionality as this library and works with C++98 & Boost.

 ## How to use

@@ -42,19 +47,28 @@ In the case of file open error, it will throw `std::runtime_error`.

 You can also pass a `stream` to the  `toml::parse` function after checking the status.

+Note that on __Windows OS__, stream that is opened as text-mode automatically converts
+CRLF ("\r\n") into LF ("\n") and this leads inconsistency between file size and
+the contents that would be read. This causes weird error. To use a file stream
+with `toml::parse`, don't forget to pass binary mode flag when you open the
+stream.
+
 ```cpp
-std::ifstream ifs("sample.toml");
+std::ifstream ifs("sample.toml", std::ios_base::binary);
 assert(ifs.good());
 const auto data = toml::parse(ifs /*, "filename" (optional)*/);
 ```

-To show a better error message, it is recommended to pass a filename with `istream`. See also [in the case of syntax error](#in-the-case-of-syntax-error) and [passing invalid type to toml::get](#passing-invalid-type-to-tomlget).
+To show a better error message, it is recommended to pass a filename with `istream`.
+See also [in the case of syntax error](#in-the-case-of-syntax-error)
+and [passing invalid type to toml::get](#passing-invalid-type-to-tomlget).

 ### In the case of syntax error

 If there is a syntax error in a toml file, `toml::parse` will throw `toml::syntax_error`.

-toml11 now has clean and informative error messages inspired by Rust and it looks like the following (comment after hash sign are actually not shown).
+toml11 now has clean and informative error messages inspired by Rust and
+it looks like the following (comment after hash sign are actually not shown).

 ```console
 terminate called after throwing an instance of 'toml::syntax_error'
@@ -64,7 +78,8 @@ terminate called after throwing an instance of 'toml::syntax_error'
   |        ^------ expected newline, but got '='.        # error reason
 ```

-If you (mistakenly) duplicate tables and got an error, you may want to see where the other is. toml11 shows both at the same time.
+If you (mistakenly) duplicate tables and got an error, you may want to see
+where the other is. toml11 shows both at the same time.

 ```console
 terminate called after throwing an instance of 'toml::syntax_error'
@@ -77,11 +92,14 @@ terminate called after throwing an instance of 'toml::syntax_error'
   | ~~~~~~~ table defined twice
 ```

-Since the error message generation is generally a difficult task, the current status is not ideal. toml11 needs your help. If you encounter a weird error message, please let us know and contribute to improve the quality!
+Since the error message generation is generally a difficult task, the current
+status is not ideal. toml11 needs your help. If you encounter a weird error message,
+please let us know and contribute to improve the quality!

 ### Getting a toml value

-After parsing successfully, you can obtain the values from the result of `toml::parse` (here, `data`) using `toml::get` function.
+After parsing successfully, you can obtain the values from the result of
+`toml::parse` (here, `data`) using `toml::get` function.

 ```toml
 answer  = 42
@@ -101,18 +119,22 @@ const auto tab       = toml::get<toml::Table>(data.at("tab"));
 const auto key       = toml::get<std::string>( tab.at("key"));
 ```

-When you pass an exact TOML type that does not require type conversion, `toml::get` returns also a reference through which you can modify the content.
+When you pass an exact TOML type that does not require type conversion,
+`toml::get` returns also a reference through which you can modify the content.

 ```cpp
 toml::get<toml::integer>(data["answer"]) = 6 * 9;
 std::cout << toml::get<int>(data.at("answer")) << std::endl; // 54
 ```

-If the specified type requires conversion, you can't take a reference to the value. See also [underlying types](#underlying-types).
+If the specified type requires conversion, you can't take a reference to the value.
+See also [underlying types](#underlying-types).

 #### Passing invalid type to toml::get

-If you choose the invalid type, `toml::type_error` will be thrown. Similar to the `syntax_error`, toml11 also displays informative error messages. The error message when you choose `int` to get `string` value would be like this.
+If you choose the invalid type, `toml::type_error` will be thrown.
+Similar to the `syntax_error`, toml11 also displays informative error messages.
+The error message when you choose `int` to get `string` value would be like this.

 ```console
 terminate called after throwing an instance of 'toml::type_error'
@@ -122,7 +144,9 @@ terminate called after throwing an instance of 'toml::type_error'
   |         ~~~~~~~~~~~~~~ the actual type is string
 ```

-NOTE: In order to show this kind of error message, all the toml values have 1 shared_ptr that points the corresponding byte sequence and 2 iterators that point the range. It is recommended to destruct all the `toml::value` classes after configuring your application to save memory resources.
+NOTE: In order to show this kind of error message, all the toml values have 1
+`shared_ptr` that points the corresponding byte sequence and 2 iterators that point the range.
+It is recommended to destruct all the `toml::value` classes after configuring your application to save memory resources.

 ### Getting arrays

@@ -157,20 +181,25 @@ const auto aofa = toml::get<
    >(data.at("aofa"));
 ```

-If you don't know what the type is inside the array, you can use `toml::array`, which is a `std::vector` of `toml::value`, instead.
+If you don't know what the type is inside the array, you can use `toml::array`,
+which is a `std::vector` of `toml::value`, instead.

 ```cpp
 const auto aofa  = toml::get<toml::array>(data.at("aofa"));
 const auto first = toml::get<toml::array>(aofa.at(0));
 ```

-See also [expecting conversion](#expecting-conversion) and [checking-value-type](#checking-value-type).
+See also [expecting conversion](#expecting-conversion)
+and [checking-value-type](#checking-value-type).

 ### Getting tables

-`toml::table` is a key component of this library, which is an alias of a `std::unordered_map` from `toml::key (a.k.a. std::string)` to `toml::value`. `toml::parse` returns this as a result.
+`toml::table` is a key component of this library, which is an alias of
+a `std::unordered_map` from `toml::key (a.k.a. std::string)` to `toml::value`.
+`toml::parse` returns this.

-Since it is just an alias of `std::unordered_map`, it has all the functionalities that `std::unordered_map` has, e.g. `operator[]`, `count`, and `find`.
+Since it is just an alias of `std::unordered_map`, it has all the functionalities
+that `std::unordered_map` has, e.g. `operator[]`, `count`, and `find`.

 ```cpp
 toml::table data = toml::parse("example.toml");
@@ -180,7 +209,8 @@ if(data.count("title") != 0)
 }
 ```

-When all the values of the table have the same type, toml11 allows you to convert a `toml::table` to a `map` that contains the convertible type.
+When all the values of the table have the same type, toml11 allows you to
+convert a `toml::table` to a `map` that contains the convertible type.

 ```toml
 [tab]
@@ -196,7 +226,8 @@ std::cout << tab["key2"] << std::endl; // bar

 ### Dotted keys

-TOML v0.5.0 has a new feature named "dotted keys". You can chain keys to represent the structure of the data.
+TOML v0.5.0 has a new feature named "dotted keys".
+You can chain keys to represent the structure of the data.

 ```toml
 physical.color = "orange"
@@ -220,7 +251,8 @@ const auto color    = toml::get<std::string>(physical.at("color"));

 ### An array of tables

-An array of tables is just an array of tables. You can get it completely in the same way as the other arrays and tables.
+An array of tables is just an array of tables.
+You can get it completely in the same way as the other arrays and tables.

 ```toml
 array_of_inline_table = [{key = "value1"}, {key = "value2"}, {key = "value3"}]
@@ -240,7 +272,9 @@ const auto aot2 = toml::get<std::vector<toml::table>>(data.at("array_of_table"))

 ### Cost of conversion

-Although `toml::get` is convenient, it has additional copy-cost because it copies data contained in `toml::value` to the user-specified type. Of course in some case this overhead is not ignorable.
+Although `toml::get` is convenient, it has additional copy-cost because
+it copies data contained in `toml::value` to the user-specified type.
+Of course in some case this overhead is not ignorable.

 By passing the exact types, `toml::get` returns reference that has nealy zero overhead.

@@ -249,7 +283,8 @@ const auto& tab     = toml::get<toml::array>(data.at("tab"));
 const auto& numbers = toml::get<toml::table>(data.at("numbers"));
 ```

-Unfortunately, in this case you need to call `toml::get` each time you access to the element of `toml::array` because `toml::array` is an array of `toml::value`.
+Unfortunately, in this case you need to call `toml::get` each time you access to
+the element of `toml::array` because `toml::array` is an array of `toml::value`.

 ```cpp
 const auto& num0 = toml::get<toml::integer>(numbers.at(0));
@@ -259,7 +294,9 @@ const auto& num2 = toml::get<toml::integer>(numbers.at(2));

 ### Datetime and its variants

-TOML v0.5.0 has 4 different datetime objects, `local_date`, `local_time`, `local_datetime`, and `offset_datetime`. With toml11, you can convert `local_time` to your favorite `std::chrono::duration` and others to `std::chrono::system_clock::time_point`.
+TOML v0.5.0 has 4 different datetime objects, `local_date`, `local_time`,
+`local_datetime`, and `offset_datetime`. With toml11, you can convert `local_time`
+to your favorite `std::chrono::duration` and others to `std::chrono::system_clock::time_point`.

 ```toml
 time = 12:30:00
@@ -284,7 +321,8 @@ const auto value = toml::get_or(data, "key", 42); // value => int 42.

 ### Expecting conversion

-By using `toml::expect`, you will get your expected value or an error message without throwing `toml::type_error`.
+By using `toml::expect`, you will get your expected value or an error message
+without throwing `toml::type_error`.

 ```cpp
 const auto value = toml::expect<std::string>(data.at("title"));
@@ -307,7 +345,9 @@ const auto value = toml::expect<int>(data.at("number"))

 ### Finding value from table

-toml11 provides utility function to find a value from `toml::table`. Of course, you can do this in your own way with `toml::get` because it just searches an  `unordered_map` and returns a value if it exists.
+toml11 provides utility function to find a value from `toml::table`.
+Of course, you can do this in your own way with `toml::get` because
+it just searches an  `unordered_map` and returns a value if it exists.

 ```cpp
 const auto data = toml::parse("example.toml");
@@ -321,7 +361,8 @@ terminate called after throwing an instance of 'std::out_of_range'
  what():  [error] key "num" not found in example.toml
 ```

-You can use this with a `toml::value` that is expected to be a `toml::table`. It automatically casts the value to table.
+You can use this with a `toml::value` that is expected to be a `toml::table`.
+It automatically casts the value to table.

 ```cpp
 const auto data = toml::parse("example.toml");
@@ -331,7 +372,8 @@ const auto num  = toml::find<int>(data.at("table"), "num");
 // num = 42
 ```

-In this case, because the value `data.at("table")` knows the locatoin of itself, you don't need to pass where you find the value. `toml::find` will show you a great error message.
+In this case, because the value `data.at("table")` knows the locatoin of itself,
+you don't need to pass where you find the value. `toml::find` will show you a great error message.

 ```console
 terminate called after throwing an instance of 'std::out_of_range'
@@ -381,9 +423,26 @@ int i = 0;
 toml::from_toml(i, data.at("something"));
 ```

+### visiting toml::value
+
+TOML v2.1.0+ provides `toml::visit` to apply a function to `toml::value` in the
+same way as `std::variant`.
+
+```cpp
+const toml::value v(3.14);
+toml::visit([](const auto& val) -> void {
+        std::cout << val << std::endl;
+    }, v);
+```
+
+The function object that would be passed to `toml::visit` must be able to
+recieve all the possible TOML types. Also, the result types should be the same
+each other.
+
 ### Sanitizing UTF-8 codepoints

-toml11 shows warning if a value of an escape sequence used to represent unicode character exceeds the unicode range.
+toml11 shows warning if a value of an escape sequence used
+to represent unicode character exceeds the unicode range.

 ```console
 [warning] input codepoint (0011FFFF) is too large to decode as a unicode character. The result may not be able to render to your screen.
@@ -455,6 +514,97 @@ you will get an error message like this.
   |       ~~ maximum number here
 ```

+### Serializing TOML data
+
+toml11 v2.1.0 enables you to serialize data into toml format.
+
+```cpp
+const auto data = toml::table{{"foo", 42}, {"bar", "baz"}};
+
+const std::string serial = toml::format(data);
+// serial == "{bar=\"baz\",foo=42}"
+
+std::cout << data << std::endl;
+// bar = "baz"
+// foo = 42
+```
+
+toml11 automatically makes a tiny table and array inline.
+You can specify the width to make them inline by `std::setw` for streams.
+
+```cpp
+const auto data = toml::table{
+    {"qux",    toml::table{{"foo", 42}, {"bar", "baz"}}},
+    {"quux",   toml::array{"small", "array", "of", "strings"}},
+    {"foobar", toml::array{"this", "array", "of", "strings", "is", "too", "long",
+                           "to", "print", "into", "single", "line", "isn't", "it?"}},
+};
+
+// the threshold becomes 80.
+std::cout << std::setw(80) << data << std::endl;
+// foobar = [
+// "this","array","of","strings","is","too","long","to","print","into",
+// "single","line","isn't","it?",
+// ]
+// quux = ["small","array","of","strings"]
+// qux = {bar="baz",foo=42}
+
+
+// the width is 0. nothing become inline.
+std::cout << std::setw(0) << data << std::endl;
+// foobar = [
+// "this",
+// ... (snip)
+// "it?",
+// ]
+// quux = [
+// "small",
+// "array",
+// "of",
+// "strings",
+// ]
+// [qux]
+// bar = "baz"
+// foo = 42
+```
+
+It is recommended to set width before printing data. Some I/O functions changes
+width to 0, and it makes all the stuff (including `toml::array`) multiline.
+The resulting files becomes too long.
+
+`toml::format` receives optional second argument to set the width.
+By default, it is 80.
+
+```cpp
+const auto data = toml::table{
+    {"qux", toml::table{{"foo", 42}, {"bar", "baz"}}}
+};
+
+const std::string serial = toml::format(data, /*width = */ 0);
+// [qux]
+// bar = "baz"
+// foo = 42
+```
+
+To control the precision of floating point numbers, you need to pass
+`std::setprecision` to stream or pass `int` to the optional third argument of
+`toml::format` (by default, it is `std::numeric_limits<double>::max_digit10`).
+
+```cpp
+const auto data = toml::table{
+    {"pi", 3.141592653589793},
+    {"e",  2.718281828459045}
+};
+std::cout << std::setprecision(17) << data << std::endl;
+// e = 2.7182818284590451
+// pi = 3.1415926535897931
+std::cout << std::setprecision( 7) << data << std::endl;
+// e = 2.718282
+// pi = 3.141593
+
+const std::string serial = toml::format(data, /*width = */ 0, /*prec = */ 17);
+```
+
 ## Underlying types

 The toml types (can be used as `toml::*` in this library) and corresponding `enum` names are listed in the table below.
@@ -470,11 +620,16 @@ The toml types (can be used as `toml::*` in this library) and corresponding `enu
 | LocalDatetime  | `toml::local_datetime`                       | `toml::value_t::LocalDatetime`  |
 | OffsetDatetime | `toml::offset_datetime`                      | `toml::value_t::offsetDatetime` |
 | Array          | `std::vector<toml::value>`                   | `toml::value_t::Array`          |
-| Table          | `std::unordered_map<std::string, toml::key>` | `toml::value_t::Table`          |
+| Table          | `std::unordered_map<toml::key, toml::value>` | `toml::value_t::Table`          |

-`toml::string` is effectively the same as `std::string` but has an additional flag that represents a kind of a string, `string_t::basic` and `string_t::literal`. Although `std::string` is not an exact toml type, still you can get a reference that points to internal `std::string` by using `toml::get<std::string>()` for convenience.
+`toml::string` is effectively the same as `std::string` but has an additional
+flag that represents a kind of a string, `string_t::basic` and `string_t::literal`.
+Although `std::string` is not an exact toml type, still you can get a reference
+that points to internal `std::string` by using `toml::get<std::string>()` for convenience.

-`Datetime` variants are `struct` that are defined in this library. Because `std::chrono::system_clock::time_point` is a __time point__, not capable of representing a Local Time independent from a specific day.
+`Datetime` variants are `struct` that are defined in this library.
+Because `std::chrono::system_clock::time_point` is a __time point__,
+not capable of representing a Local Time independent from a specific day.

 It is recommended to get `Datetime`s as `std::chrono` classes through `toml::get`.

@@ -485,6 +640,8 @@ I thank the contributor for providing great feature to this repository.
 - Guillaume Fraux (@Luthaf)
  - Windows support and CI on Appvayor
  - Intel Compiler support
+- Quentin Khan (@xaxousis)
+  - Found & Fixed a bug around ODR

 ## Licensing terms

--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -25,6 +25,7 @@ set(TEST_NAMES
    test_to_toml
    test_from_toml
    test_parse_file
+    test_serialize_file
    test_parse_unicode
    test_error_detection
 )
--- a/tests/test_parse_file.cpp
+++ b/tests/test_parse_file.cpp
@@ -213,6 +213,22 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM)
        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
    }
+    {
+        const std::string table(
+            "\xEF\xBB\xBF" // BOM
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            );
+        {
+            std::ofstream ofs("tmp.toml");
+            ofs << table;
+        }
+        const auto data = toml::parse("tmp.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
    {
        const std::string table(
            "\xEF\xBB\xBF" // BOM
@@ -223,6 +239,25 @@ BOOST_AUTO_TEST_CASE(test_file_with_BOM)
        std::istringstream iss(table);
        const auto data = toml::parse(iss, "test_file_with_BOM_CRLF.toml");

+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+    {
+        const std::string table(
+            "\xEF\xBB\xBF" // BOM
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            );
+        {
+            // with text-mode, "\n" is converted to "\r\n" and the resulting
+            // value will be "\r\r\n". To avoid the additional "\r", use binary
+            // mode.
+            std::ofstream ofs("tmp.toml", std::ios_base::binary);
+            ofs.write(table.data(), table.size());
+        }
+        const auto data = toml::parse("tmp.toml");
+
        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
    }
--- a/tests/test_parse_key.cpp
+++ b/tests/test_parse_key.cpp
@@ -13,23 +13,23 @@ using namespace detail;

 BOOST_AUTO_TEST_CASE(test_bare_key)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "barekey",  std::vector<key>(1, "barekey"));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "bare-key", std::vector<key>(1, "bare-key"));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "bare_key", std::vector<key>(1, "bare_key"));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "1234",     std::vector<key>(1, "1234"));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "barekey",  std::vector<key>(1, "barekey"));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "bare-key", std::vector<key>(1, "bare-key"));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "bare_key", std::vector<key>(1, "bare_key"));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "1234",     std::vector<key>(1, "1234"));
 }

 BOOST_AUTO_TEST_CASE(test_quoted_key)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "\"127.0.0.1\"",          std::vector<key>(1, "127.0.0.1"         ));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "\"character encoding\"", std::vector<key>(1, "character encoding"));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "\"127.0.0.1\"",          std::vector<key>(1, "127.0.0.1"         ));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "\"character encoding\"", std::vector<key>(1, "character encoding"));
 #if defined(_MSC_VER) || defined(__INTEL_COMPILER)
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "\"\xCA\x8E\xC7\x9D\xCA\x9E\"", std::vector<key>(1, "\xCA\x8E\xC7\x9D\xCA\x9E"));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "\"\xCA\x8E\xC7\x9D\xCA\x9E\"", std::vector<key>(1, "\xCA\x8E\xC7\x9D\xCA\x9E"));
 #else
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "\"ʎǝʞ\"",                std::vector<key>(1, "ʎǝʞ"               ));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "\"ʎǝʞ\"",                std::vector<key>(1, "ʎǝʞ"               ));
 #endif
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "'key2'",                 std::vector<key>(1, "key2"              ));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "'quoted \"value\"'",     std::vector<key>(1, "quoted \"value\""  ));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "'key2'",                 std::vector<key>(1, "key2"              ));
+    TOML11_TEST_PARSE_EQUAL(parse_key, "'quoted \"value\"'",     std::vector<key>(1, "quoted \"value\""  ));
 }

 BOOST_AUTO_TEST_CASE(test_dotted_key)
@@ -38,13 +38,13 @@ BOOST_AUTO_TEST_CASE(test_dotted_key)
        std::vector<key> keys(2);
        keys[0] = "physical";
        keys[1] = "color";
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "physical.color", keys);
+        TOML11_TEST_PARSE_EQUAL(parse_key, "physical.color", keys);
    }
    {
        std::vector<key> keys(2);
        keys[0] = "physical";
        keys[1] = "shape";
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "physical.shape", keys);
+        TOML11_TEST_PARSE_EQUAL(parse_key, "physical.shape", keys);
    }
    {
        std::vector<key> keys(4);
@@ -52,12 +52,12 @@ BOOST_AUTO_TEST_CASE(test_dotted_key)
        keys[1] = "y";
        keys[2] = "z";
        keys[3] = "w";
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "x.y.z.w", keys);
+        TOML11_TEST_PARSE_EQUAL(parse_key, "x.y.z.w", keys);
    }
    {
        std::vector<key> keys(2);
        keys[0] = "site";
        keys[1] = "google.com";
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_key, "site.\"google.com\"", keys);
+        TOML11_TEST_PARSE_EQUAL(parse_key, "site.\"google.com\"", keys);
    }
 }
--- a/tests/test_serialize_file.cpp
+++ b/tests/test_serialize_file.cpp
@@ -0,0 +1,54 @@
+#define BOOST_TEST_MODULE "test_serialize_file"
+#ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST
+#include <boost/test/unit_test.hpp>
+#else
+#define BOOST_TEST_NO_LIB
+#include <boost/test/included/unit_test.hpp>
+#endif
+#include <toml.hpp>
+#include <iostream>
+#include <fstream>
+
+
+BOOST_AUTO_TEST_CASE(test_example)
+{
+    const auto data = toml::parse("toml/tests/example.toml");
+    {
+        std::ofstream ofs("tmp1.toml");
+        ofs << std::setw(80) << data;
+    }
+
+    auto serialized = toml::parse("tmp1.toml");
+    {
+        auto& owner = toml::get<toml::table>(serialized.at("owner"));
+        auto& bio   = toml::get<std::string>(owner.at("bio"));
+        const auto CR = std::find(bio.begin(), bio.end(), '\r');
+        if(CR != bio.end())
+        {
+            bio.erase(CR);
+        }
+    }
+    BOOST_CHECK(data == serialized);
+}
+
+BOOST_AUTO_TEST_CASE(test_fruit)
+{
+    const auto data = toml::parse("toml/tests/fruit.toml");
+    {
+        std::ofstream ofs("tmp2.toml");
+        ofs << std::setw(80) << data;
+    }
+    const auto serialized = toml::parse("tmp2.toml");
+    BOOST_CHECK(data == serialized);
+}
+
+BOOST_AUTO_TEST_CASE(test_hard_example)
+{
+    const auto data = toml::parse("toml/tests/hard_example.toml");
+    {
+        std::ofstream ofs("tmp3.toml");
+        ofs << std::setw(80) << data;
+    }
+    const auto serialized = toml::parse("tmp3.toml");
+    BOOST_CHECK(data == serialized);
+}
--- a/toml.hpp
+++ b/toml.hpp
@@ -34,6 +34,7 @@
 #endif

 #include "toml/parser.hpp"
+#include "toml/serializer.hpp"
 #include "toml/to_toml.hpp"
 #include "toml/from_toml.hpp"
 #include "toml/get.hpp"
--- a/toml/combinator.hpp
+++ b/toml/combinator.hpp
@@ -39,7 +39,7 @@ inline std::string show_char(const char c)
    else
    {
        std::ostringstream oss;
-        oss << std::hex << std::setfill('0') << std::setw(2) << "0x"
+        oss << "0x" << std::hex << std::setfill('0') << std::setw(2)
            << static_cast<int>(c);
        return oss.str();
    }
--- a/toml/datetime.hpp
+++ b/toml/datetime.hpp
@@ -14,6 +14,36 @@
 namespace toml
 {

+// To avoid non-threadsafe std::localtime. In C11 (not C++11!), localtime_s is
+// provided in the absolutely same purpose, but C++11 is actually not compatible
+// with C11. We need to dispatch the function depending on the OS.
+namespace detail
+{
+// TODO: find more sophisticated way to handle this
+#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE || _POSIX_SOURCE
+inline std::tm localtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::localtime_r(src, &dst);
+    if(!result)
+    {
+        throw std::runtime_error("localtime_r failed.");
+    }
+    return dst;
+}
+#else
+// XXX: On Windows, std::localtime is thread-safe because they uses thread-local
+// storage to store the instance of std::tm. On the other platforms, it may not
+// be thread-safe.
+inline std::tm localtime_s(const std::time_t* src)
+{
+    const auto result = std::localtime(src);
+    if(!result) {throw std::runtime_error("localtime failed.");}
+    return *result;
+}
+#endif
+} // detail
+
 enum class month_t : std::int8_t
 {
    Jan =  0,
@@ -50,10 +80,8 @@ struct local_date

    explicit local_date(const std::chrono::system_clock::time_point& tp)
    {
-        const auto t = std::chrono::system_clock::to_time_t(tp);
-        const auto tmp = std::localtime(&t); //XXX: not threadsafe!
-        assert(tmp); // if std::localtime fails, tmp is nullptr
-        const std::tm time = *tmp;
+        const auto t    = std::chrono::system_clock::to_time_t(tp);
+        const auto time = detail::localtime_s(&t);
        *this = local_date(time);
    }

@@ -330,10 +358,8 @@ struct local_datetime
    explicit local_datetime(const std::chrono::system_clock::time_point& tp)
    {
        const auto t = std::chrono::system_clock::to_time_t(tp);
-        const auto tmp = std::localtime(&t); //XXX: not threadsafe!
-        assert(tmp); // if std::localtime fails, tmp is nullptr
+        std::tm time = detail::localtime_s(&t);

-        std::tm time = *tmp;
        this->date = local_date(time);
        this->time = local_time(time);

@@ -482,10 +508,8 @@ struct offset_datetime
    static time_offset get_local_offset()
    {
         // get current timezone
-        const auto  tmp1 = std::time(nullptr);
-        const auto  tmp2 = std::localtime(&tmp1); // XXX not threadsafe!
-        assert(tmp2);
-        std::tm t = *tmp2;
+        const auto tmp1 = std::time(nullptr);
+        const auto t    = detail::localtime_s(&tmp1);

        std::array<char, 6> buf;
        const auto result = std::strftime(buf.data(), 6, "%z", &t); // +hhmm\0
--- a/toml/lexer.hpp
+++ b/toml/lexer.hpp
@@ -124,9 +124,9 @@ using lex_escape_unicode_short = sequence<character<'u'>,
 using lex_escape_unicode_long  = sequence<character<'U'>,
                                          repeat<lex_hex_dig, exactly<8>>>;
 using lex_escape_seq_char = either<character<'"'>, character<'\\'>,
-                                   character<'/'>, character<'b'>,
-                                   character<'f'>, character<'n'>,
-                                   character<'r'>, character<'t'>,
+                                   character<'b'>, character<'f'>,
+                                   character<'n'>, character<'r'>,
+                                   character<'t'>,
                                   lex_escape_unicode_short,
                                   lex_escape_unicode_long
                                   >;
--- a/toml/parser.hpp
+++ b/toml/parser.hpp
@@ -34,7 +34,7 @@ parse_boolean(location<Container>& loc)
        }
    }
    loc.iter() = first; //rollback
-    return err(std::string("[error] toml::parse_boolean: "
+    return err(format_underline("[error] toml::parse_boolean: ", loc,
                           "the next token is not a boolean"));
 }

@@ -63,7 +63,7 @@ parse_binary_integer(location<Container>& loc)
        return ok(std::make_pair(retval, token.unwrap()));
    }
    loc.iter() = first;
-    return err(std::string("[error] toml::parse_binary_integer:"
+    return err(format_underline("[error] toml::parse_binary_integer:", loc,
                           "the next token is not an integer"));
 }

@@ -84,7 +84,7 @@ parse_octal_integer(location<Container>& loc)
        return ok(std::make_pair(retval, token.unwrap()));
    }
    loc.iter() = first;
-    return err(std::string("[error] toml::parse_octal_integer:"
+    return err(format_underline("[error] toml::parse_octal_integer:", loc,
                           "the next token is not an integer"));
 }

@@ -105,7 +105,7 @@ parse_hexadecimal_integer(location<Container>& loc)
        return ok(std::make_pair(retval, token.unwrap()));
    }
    loc.iter() = first;
-    return err(std::string("[error] toml::parse_hexadecimal_integer"
+    return err(format_underline("[error] toml::parse_hexadecimal_integer", loc,
                           "the next token is not an integer"));
 }

@@ -133,7 +133,7 @@ parse_integer(location<Container>& loc)
        return ok(std::make_pair(retval, token.unwrap()));
    }
    loc.iter() = first;
-    return err(std::string("[error] toml::parse_integer: "
+    return err(format_underline("[error] toml::parse_integer: ", loc,
                           "the next token is not an integer"));
 }

@@ -222,12 +222,13 @@ parse_floating(location<Container>& loc)
        return ok(std::make_pair(v, token.unwrap()));
    }
    loc.iter() = first;
-    return err(std::string("[error] toml::parse_floating: "
+    return err(format_underline("[error] toml::parse_floating: ", loc,
                           "the next token is not a float"));
 }

-template<typename Container>
-std::string read_utf8_codepoint(const region<Container>& reg)
+template<typename Container, typename Container2>
+std::string read_utf8_codepoint(const region<Container>& reg,
+              /* for err msg */ const location<Container2>& loc)
 {
    const auto str = reg.str().substr(1);
    std::uint_least32_t codepoint;
@@ -247,20 +248,27 @@ std::string read_utf8_codepoint(const region<Container>& reg)
    }
    else if(codepoint < 0x10000) // U+0800...U+FFFF
    {
+        if(0xD800 <= codepoint && codepoint <= 0xDFFF)
+        {
+            std::cerr << format_underline("[warning] "
+                "toml::read_utf8_codepoint: codepoints in the range "
+                "[0xD800, 0xDFFF] are not valid UTF-8.",
+                loc, "not a valid UTF-8 codepoint") << std::endl;
+        }
+        assert(codepoint < 0xD800 || 0xDFFF < codepoint);
        // 1110yyyy 10yxxxxx 10xxxxxx
        character += static_cast<unsigned char>(0xE0| codepoint >> 12);
        character += static_cast<unsigned char>(0x80|(codepoint >> 6 & 0x3F));
        character += static_cast<unsigned char>(0x80|(codepoint      & 0x3F));
    }
-    else if(codepoint < 0x200000) // U+10000 ... U+1FFFFF
+    else if(codepoint < 0x200000) // U+010000 ... U+1FFFFF
    {
        if(0x10FFFF < codepoint) // out of Unicode region
        {
-            std::cerr << format_underline(concat_to_string("[warning] "
-                    "input codepoint (", str, ") is too large to decode as "
-                    "a unicode character. The result may not be able to render "
-                    "to your screen."), reg, "should be in [0x00..0x10FFFF]")
-                      << std::endl;
+            std::cerr << format_underline("[error] "
+                "toml::read_utf8_codepoint: input codepoint is too large to "
+                "decode as a unicode character.", loc,
+                "should be in [0x00..0x10FFFF]") << std::endl;
        }
        // 11110yyy 10yyxxxx 10xxxxxx 10xxxxxx
        character += static_cast<unsigned char>(0xF0| codepoint >> 18);
@@ -283,7 +291,7 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& loc)
    const auto first = loc.iter();
    if(first == loc.end() || *first != '\\')
    {
-        return err(std::string("[error]: toml::parse_escape_sequence: "
+        return err(format_underline("[error]: toml::parse_escape_sequence: ", loc,
                    "the next token is not an escape sequence \"\\\""));
    }
    ++loc.iter();
@@ -300,7 +308,7 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& loc)
        {
            if(const auto token = lex_escape_unicode_short::invoke(loc))
            {
-                return ok(read_utf8_codepoint(token.unwrap()));
+                return ok(read_utf8_codepoint(token.unwrap(), loc));
            }
            else
            {
@@ -313,7 +321,7 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& loc)
        {
            if(const auto token = lex_escape_unicode_long::invoke(loc))
            {
-                return ok(read_utf8_codepoint(token.unwrap()));
+                return ok(read_utf8_codepoint(token.unwrap(), loc));
            }
            else
            {
@@ -523,7 +531,7 @@ parse_string(location<Container>& loc)
    if(const auto rslt = parse_ml_literal_string(loc)) {return rslt;}
    if(const auto rslt = parse_basic_string(loc))      {return rslt;}
    if(const auto rslt = parse_literal_string(loc))    {return rslt;}
-    return err(std::string("[error] toml::parse_string: "
+    return err(format_underline("[error] toml::parse_string: ", loc,
                "the next token is not a string"));
 }

@@ -573,7 +581,7 @@ parse_local_date(location<Container>& loc)
    else
    {
        loc.iter() = first;
-        return err(std::string("[error]: toml::parse_local_date: "
+        return err(format_underline("[error]: toml::parse_local_date: ", loc,
                    "the next token is not a local_date"));
    }
 }
@@ -656,7 +664,7 @@ parse_local_time(location<Container>& loc)
    else
    {
        loc.iter() = first;
-        return err(std::string("[error]: toml::parse_local_time: "
+        return err(format_underline("[error]: toml::parse_local_time: ", loc,
                    "the next token is not a local_time"));
    }
 }
@@ -699,7 +707,7 @@ parse_local_datetime(location<Container>& loc)
    else
    {
        loc.iter() = first;
-        return err(std::string("[error]: toml::parse_local_datetime: "
+        return err(format_underline("[error]: toml::parse_local_datetime: ", loc,
                    "the next token is not a local_datetime"));
    }
 }
@@ -748,39 +756,43 @@ parse_offset_datetime(location<Container>& loc)
    else
    {
        loc.iter() = first;
-        return err(std::string("[error]: toml::parse_offset_datetime: "
+        return err(format_underline("[error]: toml::parse_offset_datetime: ", loc,
                    "the next token is not a local_datetime"));
    }
 }

 template<typename Container>
-result<key, std::string> parse_simple_key(location<Container>& loc)
+result<std::pair<key, region<Container>>, std::string>
+parse_simple_key(location<Container>& loc)
 {
    if(const auto bstr = parse_basic_string(loc))
    {
-        return ok(bstr.unwrap().first.str);
+        return ok(std::make_pair(bstr.unwrap().first.str, bstr.unwrap().second));
    }
    if(const auto lstr = parse_literal_string(loc))
    {
-        return ok(lstr.unwrap().first.str);
+        return ok(std::make_pair(lstr.unwrap().first.str, lstr.unwrap().second));
    }
    if(const auto bare = lex_unquoted_key::invoke(loc))
    {
-        return ok(bare.unwrap().str());
+        const auto reg = bare.unwrap();
+        return ok(std::make_pair(reg.str(), reg));
    }
-    return err(std::string("[error] toml::parse_simple_key: "
+    return err(format_underline("[error] toml::parse_simple_key: ", loc,
        "the next token is not a simple key"));
 }

 // dotted key become vector of keys
 template<typename Container>
-result<std::vector<key>, std::string> parse_key(location<Container>& loc)
+result<std::pair<std::vector<key>, region<Container>>, std::string>
+parse_key(location<Container>& loc)
 {
    const auto first = loc.iter();
    // dotted key -> foo.bar.baz whitespaces are allowed
    if(const auto token = lex_dotted_key::invoke(loc))
    {
-        location<std::string> inner_loc(loc.name(), token.unwrap().str());
+        const auto reg = token.unwrap();
+        location<std::string> inner_loc(loc.name(), reg.str());
        std::vector<key> keys;

        while(inner_loc.iter() != inner_loc.end())
@@ -788,7 +800,7 @@ result<std::vector<key>, std::string> parse_key(location<Container>& loc)
            lex_ws::invoke(inner_loc);
            if(const auto k = parse_simple_key(inner_loc))
            {
-                keys.push_back(k.unwrap());
+                keys.push_back(k.unwrap().first);
            }
            else
            {
@@ -813,17 +825,17 @@ result<std::vector<key>, std::string> parse_key(location<Container>& loc)
                    "should be `.`"));
            }
        }
-        return ok(keys);
+        return ok(std::make_pair(keys, reg));
    }
    loc.iter() = first;

    // simple key -> foo
    if(const auto smpl = parse_simple_key(loc))
    {
-        return ok(std::vector<key>(1, smpl.unwrap()));
+        return ok(std::make_pair(std::vector<key>(1, smpl.unwrap().first),
+                                 smpl.unwrap().second));
    }
-    return err(std::string("[error] toml::parse_key: "
-                           "the next token is not a key"));
+    return err(format_underline("[error] toml::parse_key: ", loc, "is not a valid key"));
 }

 // forward-decl to implement parse_array and parse_table
@@ -864,16 +876,39 @@ parse_array(location<Container>& loc)
        {
            if(!retval.empty() && retval.front().type() != val.as_ok().type())
            {
-                throw syntax_error(format_underline(
-                    "[error] toml::parse_array: type of elements should be the "
-                    "same each other.", region<Container>(loc, first, loc.iter()),
-                    "inhomogeneous types"));
+                auto array_start_loc = loc;
+                array_start_loc.iter() = first;
+
+                throw syntax_error(format_underline("[error] toml::parse_array: "
+                    "type of elements should be the same each other.",
+                    std::vector<std::pair<region_base const*, std::string>>{
+                        std::make_pair(
+                            std::addressof(array_start_loc),
+                            std::string("array starts here")
+                        ),
+                        std::make_pair(
+                            std::addressof(get_region(retval.front())),
+                            std::string("value has type ") +
+                                stringize(retval.front().type())
+                        ),
+                        std::make_pair(
+                            std::addressof(get_region(val.unwrap())),
+                            std::string("value has different type, ") +
+                                stringize(val.unwrap().type())
+                        )
+                    }));
            }
            retval.push_back(std::move(val.unwrap()));
        }
        else
        {
-            return err(val.unwrap_err());
+            auto array_start_loc = loc;
+            array_start_loc.iter() = first;
+
+            throw syntax_error(format_underline("[error] toml::parse_array: "
+                "value having invalid format appeared in an array",
+                array_start_loc, "array starts here",
+                loc, "it is not a valid value."));
        }

        using lex_array_separator = sequence<maybe<lex_ws>, character<','>>;
@@ -889,8 +924,12 @@ parse_array(location<Container>& loc)
            }
            else
            {
+                auto array_start_loc = loc;
+                array_start_loc.iter() = first;
+
                throw syntax_error(format_underline("[error] toml::parse_array:"
-                    " missing array separator `,`", loc, "should be `,`"));
+                    " missing array separator `,` after a value",
+                    array_start_loc, "array starts here", loc, "should be `,`"));
            }
        }
    }
@@ -900,14 +939,14 @@ parse_array(location<Container>& loc)
 }

 template<typename Container>
-result<std::pair<std::vector<key>, value>, std::string>
+result<std::pair<std::pair<std::vector<key>, region<Container>>, value>, std::string>
 parse_key_value_pair(location<Container>& loc)
 {
    const auto first = loc.iter();
-    auto key = parse_key(loc);
-    if(!key)
+    auto key_reg = parse_key(loc);
+    if(!key_reg)
    {
-        std::string msg = std::move(key.unwrap_err());
+        std::string msg = std::move(key_reg.unwrap_err());
        // if the next token is keyvalue-separator, it means that there are no
        // key. then we need to show error as "empty key is not allowed".
        if(const auto keyval_sep = lex_keyval_sep::invoke(loc))
@@ -948,6 +987,7 @@ parse_key_value_pair(location<Container>& loc)
    {
        std::string msg;
        loc.iter() = after_kvsp;
+        // check there is something not a comment/whitespace after `=`
        if(sequence<maybe<lex_ws>, maybe<lex_comment>, lex_newline>::invoke(loc))
        {
            loc.iter() = after_kvsp;
@@ -955,15 +995,15 @@ parse_key_value_pair(location<Container>& loc)
                    "missing value after key-value separator '='", loc,
                    "expected value, but got nothing");
        }
-        else
+        else // there is something not a comment/whitespace, so invalid format.
        {
-            msg = format_underline("[error] toml::parse_key_value_pair: "
-                    "invalid value format", loc, val.unwrap_err());
+            msg = std::move(val.unwrap_err());
        }
        loc.iter() = first;
        return err(msg);
    }
-    return ok(std::make_pair(std::move(key.unwrap()), std::move(val.unwrap())));
+    return ok(std::make_pair(std::move(key_reg.unwrap()),
+                             std::move(val.unwrap())));
 }

 // for error messages.
@@ -982,10 +1022,80 @@ std::string format_dotted_keys(InputIterator first, const InputIterator last)
    return retval;
 }

-template<typename InputIterator>
+// forward decl for is_valid_forward_table_definition
+template<typename Container>
+result<std::pair<std::vector<key>, region<Container>>, std::string>
+parse_table_key(location<Container>& loc);
+// The following toml file is allowed.
+// ```toml
+// [a.b.c]     # here, table `a` has element `b`.
+// foo = "bar"
+// [a]         # merge a = {baz = "qux"} to a = {b = {...}}
+// baz = "qux"
+// ```
+// But the following is not allowed.
+// ```toml
+// [a]
+// b.c.foo = "bar"
+// [a]             # error! the same table [a] defined!
+// baz = "qux"
+// ```
+// The following is neither allowed.
+// ```toml
+// a = { b.c.foo = "bar"}
+// [a]             # error! the same table [a] defined!
+// baz = "qux"
+// ```
+// Here, it parses region of `tab->at(k)` as a table key and check the depth
+// of the key. If the key region points deeper node, it would be allowed.
+// Otherwise, the key points the same node. It would be rejected.
+template<typename Iterator>
+bool is_valid_forward_table_definition(const value& fwd,
+        Iterator key_first, Iterator key_curr, Iterator key_last)
+{
+    location<std::string> def("internal", detail::get_region(fwd).str());
+    if(const auto tabkeys = parse_table_key(def))
+    {
+        // table keys always contains all the nodes from the root.
+        const auto& tks = tabkeys.unwrap().first;
+        if(std::distance(key_first, key_last) == tks.size() &&
+           std::equal(tks.begin(), tks.end(), key_first))
+        {
+            // the keys are equivalent. it is not allowed.
+            return false;
+        }
+        // the keys are not equivalent. it is allowed.
+        return true;
+    }
+    if(const auto dotkeys = parse_key(def))
+    {
+        // consider the following case.
+        // [a]
+        // b.c = {d = 42}
+        // [a.b.c]
+        // e = 2.71
+        // this defines the table [a.b.c] twice. no?
+
+        // a dotted key starts from the node representing a table in which the
+        // dotted key belongs to.
+        const auto& dks = dotkeys.unwrap().first;
+        if(std::distance(key_curr, key_last) == dks.size() &&
+           std::equal(dks.begin(), dks.end(), key_curr))
+        {
+            // the keys are equivalent. it is not allowed.
+            return false;
+        }
+        // the keys are not equivalent. it is allowed.
+        return true;
+    }
+    return false;
+}
+
+template<typename InputIterator, typename Container>
 result<bool, std::string>
 insert_nested_key(table& root, const toml::value& v,
                  InputIterator iter, const InputIterator last,
+                  region<Container> key_reg,
                  const bool is_array_of_table = false)
 {
    static_assert(std::is_same<key,
@@ -1067,24 +1177,38 @@ insert_nested_key(table& root, const toml::value& v,
                }
                else // if not, we need to create the array of table
                {
-                    toml::value aot(v); // copy region info from table to array
-                    // update content by an array with one element
-                    detail::assign_keeping_region(aot,
-                            ::toml::value(toml::array(1, v)));
-
+                    toml::value aot(toml::array(1, v), key_reg);
                    tab->insert(std::make_pair(k, aot));
                    return ok(true);
                }
-            }
+            } // end if(array of table)
+
            if(tab->count(k) == 1)
            {
                if(tab->at(k).is(value_t::Table) && v.is(value_t::Table))
                {
-                    throw syntax_error(format_underline(concat_to_string(
-                        "[error] toml::insert_value: table (\"",
-                        format_dotted_keys(first, last), "\") already exists."),
-                        get_region(tab->at(k)), "table already exists here",
-                        get_region(v), "table defined twice"));
+                    if(!is_valid_forward_table_definition(
+                                tab->at(k), first, iter, last))
+                    {
+                        throw syntax_error(format_underline(concat_to_string(
+                                "[error] toml::insert_value: table (\"",
+                                format_dotted_keys(first, last),
+                                "\") already exists."),
+                            get_region(tab->at(k)), "table already exists here",
+                            get_region(v), "table defined twice"));
+                    }
+                    // to allow the following toml file.
+                    // [a.b.c]
+                    // d = 42
+                    // [a]
+                    // e = 2.71
+                    auto& t = tab->at(k).cast<value_t::Table>();
+                    for(const auto& kv : v.cast<value_t::Table>())
+                    {
+                        t[kv.first] = kv.second;
+                    }
+                    detail::change_region(tab->at(k), key_reg);
+                    return ok(true);
                }
                else if(v.is(value_t::Table)                          &&
                        tab->at(k).is(value_t::Array)                 &&
@@ -1104,7 +1228,7 @@ insert_nested_key(table& root, const toml::value& v,
                        "[error] toml::insert_value: value (\"",
                        format_dotted_keys(first, last), "\") already exists."),
                        get_region(tab->at(k)), "value already exists here",
-                        get_region(v), "value inserted twice"));
+                        get_region(v), "value defined twice"));
                }
            }
            tab->insert(std::make_pair(k, v));
@@ -1120,10 +1244,7 @@ insert_nested_key(table& root, const toml::value& v,
            // [x.y.z]
            if(tab->count(k) == 0)
            {
-                // the region of [x.y] is the same as [x.y.z].
-                (*tab)[k] = v; // copy region_info_
-                detail::assign_keeping_region((*tab)[k],
-                        ::toml::value(::toml::table{}));
+                (*tab)[k] = toml::value(toml::table{}, key_reg);
            }

            // type checking...
@@ -1167,7 +1288,7 @@ parse_inline_table(location<Container>& loc)
    table retval;
    if(!(loc.iter() != loc.end() && *loc.iter() == '{'))
    {
-        return err(std::string("[error] toml::parse_inline_table: "
+        return err(format_underline("[error] toml::parse_inline_table: ", loc,
                               "the next token is not an inline table"));
    }
    ++loc.iter();
@@ -1187,11 +1308,12 @@ parse_inline_table(location<Container>& loc)
        {
            return err(kv_r.unwrap_err());
        }
-        const std::vector<key>& keys = kv_r.unwrap().first;
-        const value&            val  = kv_r.unwrap().second;
+        const std::vector<key>&  keys    = kv_r.unwrap().first.first;
+        const region<Container>& key_reg = kv_r.unwrap().first.second;
+        const value&             val     = kv_r.unwrap().second;

        const auto inserted =
-            insert_nested_key(retval, val, keys.begin(), keys.end());
+            insert_nested_key(retval, val, keys.begin(), keys.end(), key_reg);
        if(!inserted)
        {
            throw internal_error("[error] toml::parse_inline_table: "
@@ -1228,7 +1350,7 @@ result<value, std::string> parse_value(location<Container>& loc)
    const auto first = loc.iter();
    if(first == loc.end())
    {
-        return err(std::string("[error] toml::parse_value: input is empty"));
+        return err(format_underline("[error] toml::parse_value: input is empty", loc, ""));
    }
    if(auto r = parse_string         (loc))
    {return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
@@ -1289,7 +1411,21 @@ parse_table_key(location<Container>& loc)
            throw internal_error(format_underline("[error] "
                "toml::parse_table_key: no `]`", inner_loc, "should be `]`"));
        }
-        return ok(std::make_pair(keys.unwrap(), token.unwrap()));
+
+        // after [table.key], newline or EOF(empty table) requried.
+        if(loc.iter() != loc.end())
+        {
+            using lex_newline_after_table_key =
+                sequence<maybe<lex_ws>, maybe<lex_comment>, lex_newline>;
+            const auto nl = lex_newline_after_table_key::invoke(loc);
+            if(!nl)
+            {
+                throw syntax_error(format_underline("[error] "
+                    "toml::parse_table_key: newline required after [table.key]",
+                    loc, "expected newline"));
+            }
+        }
+        return ok(std::make_pair(keys.unwrap().first, token.unwrap()));
    }
    else
    {
@@ -1327,7 +1463,21 @@ parse_array_table_key(location<Container>& loc)
            throw internal_error(format_underline("[error] "
                "toml::parse_table_key: no `]]`", inner_loc, "should be `]]`"));
        }
-        return ok(std::make_pair(keys.unwrap(), token.unwrap()));
+
+        // after [[table.key]], newline or EOF(empty table) requried.
+        if(loc.iter() != loc.end())
+        {
+            using lex_newline_after_table_key =
+                sequence<maybe<lex_ws>, maybe<lex_comment>, lex_newline>;
+            const auto nl = lex_newline_after_table_key::invoke(loc);
+            if(!nl)
+            {
+                throw syntax_error(format_underline("[error] "
+                    "toml::parse_array_table_key: newline required after "
+                    "[[table.key]]", loc, "expected newline"));
+            }
+        }
+        return ok(std::make_pair(keys.unwrap().first, token.unwrap()));
    }
    else
    {
@@ -1342,7 +1492,7 @@ result<table, std::string> parse_ml_table(location<Container>& loc)
    const auto first = loc.iter();
    if(first == loc.end())
    {
-        return err(std::string("toml::parse_ml_table: input is empty"));
+        return ok(toml::table{});
    }

    // XXX at lest one newline is needed.
@@ -1368,10 +1518,11 @@ result<table, std::string> parse_ml_table(location<Container>& loc)

        if(const auto kv = parse_key_value_pair(loc))
        {
-            const std::vector<key>& keys = kv.unwrap().first;
-            const value&            val  = kv.unwrap().second;
+            const std::vector<key>& keys     = kv.unwrap().first.first;
+            const region<Container>& key_reg = kv.unwrap().first.second;
+            const value&            val      = kv.unwrap().second;
            const auto inserted =
-                insert_nested_key(tab, val, keys.begin(), keys.end());
+                insert_nested_key(tab, val, keys.begin(), keys.end(), key_reg);
            if(!inserted)
            {
                return err(inserted.unwrap_err());
@@ -1420,11 +1571,11 @@ result<table, std::string> parse_toml_file(location<Container>& loc)
    const auto first = loc.iter();
    if(first == loc.end())
    {
-        return err(std::string("toml::detail::parse_toml_file: input is empty"));
+        return ok(toml::table{});
    }

    table data;
-    /* root object is also table, but without [tablename] */
+    // root object is also a table, but without [tablename]
    if(auto tab = parse_ml_table(loc))
    {
        data = std::move(tab.unwrap());
@@ -1449,7 +1600,8 @@ result<table, std::string> parse_toml_file(location<Container>& loc)

            const auto inserted = insert_nested_key(data,
                    toml::value(tab.unwrap(), reg),
-                    keys.begin(), keys.end(), /*is_array_of_table=*/ true);
+                    keys.begin(), keys.end(), reg,
+                    /*is_array_of_table=*/ true);
            if(!inserted) {return err(inserted.unwrap_err());}

            continue;
@@ -1463,7 +1615,7 @@ result<table, std::string> parse_toml_file(location<Container>& loc)
            const auto& reg  = tabkey.unwrap().second;

            const auto inserted = insert_nested_key(data,
-                    toml::value(tab.unwrap(), reg), keys.begin(), keys.end());
+                toml::value(tab.unwrap(), reg), keys.begin(), keys.end(), reg);
            if(!inserted) {return err(inserted.unwrap_err());}

            continue;
@@ -1517,7 +1669,7 @@ inline table parse(std::istream& is, std::string fname = "unknown file")

 inline table parse(const std::string& fname)
 {
-    std::ifstream ifs(fname.c_str());
+    std::ifstream ifs(fname.c_str(), std::ios_base::binary);
    if(!ifs.good())
    {
        throw std::runtime_error("toml::parse: file open error -> " + fname);
--- a/toml/region.hpp
+++ b/toml/region.hpp
@@ -28,44 +28,6 @@ inline std::string make_string(std::size_t len, char c)
    return std::string(len, c);
 }

-// location in a container, normally in a file content.
-// shared_ptr points the resource that the iter points.
-// it can be used not only for resource handling, but also error message.
-template<typename Container>
-struct location
-{
-    static_assert(std::is_same<char, typename Container::value_type>::value,"");
-    using const_iterator = typename Container::const_iterator;
-    using source_ptr     = std::shared_ptr<const Container>;
-
-    location(std::string name, Container cont)
-      : source_(std::make_shared<Container>(std::move(cont))),
-        source_name_(std::move(name)), iter_(source_->cbegin())
-    {}
-    location(const location&) = default;
-    location(location&&)      = default;
-    location& operator=(const location&) = default;
-    location& operator=(location&&)      = default;
-    ~location() = default;
-
-    const_iterator& iter()       noexcept {return iter_;}
-    const_iterator  iter() const noexcept {return iter_;}
-
-    const_iterator  begin() const noexcept {return source_->cbegin();}
-    const_iterator  end()   const noexcept {return source_->cend();}
-
-    source_ptr const& source() const& noexcept {return source_;}
-    source_ptr&&      source() &&     noexcept {return std::move(source_);}
-
-    std::string const& name() const noexcept {return source_name_;}
-
-  private:
-
-    source_ptr     source_;
-    std::string    source_name_;
-    const_iterator iter_;
-};
-
 // region in a container, normally in a file content.
 // shared_ptr points the resource that the iter points.
 // combinators returns this.
@@ -86,12 +48,89 @@ struct region_base
    virtual std::string line()     const {return std::string("unknown line");}
    virtual std::string line_num() const {return std::string("?");}

-
    virtual std::size_t before()   const noexcept {return 0;}
    virtual std::size_t size()     const noexcept {return 0;}
    virtual std::size_t after()    const noexcept {return 0;}
 };

+// location in a container, normally in a file content.
+// shared_ptr points the resource that the iter points.
+// it can be used not only for resource handling, but also error message.
+//
+// it can be considered as a region that contains only one character.
+template<typename Container>
+struct location final : public region_base
+{
+    static_assert(std::is_same<char, typename Container::value_type>::value,"");
+    using const_iterator = typename Container::const_iterator;
+    using source_ptr     = std::shared_ptr<const Container>;
+
+    location(std::string name, Container cont)
+      : source_(std::make_shared<Container>(std::move(cont))),
+        source_name_(std::move(name)), iter_(source_->cbegin())
+    {}
+    location(const location&) = default;
+    location(location&&)      = default;
+    location& operator=(const location&) = default;
+    location& operator=(location&&)      = default;
+    ~location() = default;
+
+    bool is_ok() const noexcept override {return static_cast<bool>(source_);}
+
+    const_iterator& iter()       noexcept {return iter_;}
+    const_iterator  iter() const noexcept {return iter_;}
+
+    const_iterator  begin() const noexcept {return source_->cbegin();}
+    const_iterator  end()   const noexcept {return source_->cend();}
+
+    std::string str()  const override {return make_string(1, *this->iter());}
+    std::string name() const override {return source_name_;}
+
+    std::string line_num() const override
+    {
+        return std::to_string(1+std::count(this->begin(), this->iter(), '\n'));
+    }
+
+    std::string line() const override
+    {
+        return make_string(this->line_begin(), this->line_end());
+    }
+
+    const_iterator line_begin() const noexcept
+    {
+        using reverse_iterator = std::reverse_iterator<const_iterator>;
+        return std::find(reverse_iterator(this->iter()),
+                         reverse_iterator(this->begin()), '\n').base();
+    }
+    const_iterator line_end() const noexcept
+    {
+        return std::find(this->iter(), this->end(), '\n');
+    }
+
+    // location is always points a character. so the size is 1.
+    std::size_t size() const noexcept override
+    {
+        return 1u;
+    }
+    std::size_t before() const noexcept override
+    {
+        return std::distance(this->line_begin(), this->iter());
+    }
+    std::size_t after() const noexcept override
+    {
+        return std::distance(this->iter(), this->line_end());
+    }
+
+    source_ptr const& source() const& noexcept {return source_;}
+    source_ptr&&      source() &&     noexcept {return std::move(source_);}
+
+  private:
+
+    source_ptr     source_;
+    std::string    source_name_;
+    const_iterator iter_;
+};
+
 template<typename Container>
 struct region final : public region_base
 {
@@ -225,7 +264,19 @@ inline std::string format_underline(const std::string& message,
    retval += make_string(line_number.size() + 1, ' ');
    retval += " | ";
    retval += make_string(reg.before(), ' ');
-    retval += make_string(reg.size(),   '~');
+    if(reg.size() == 1)
+    {
+        // invalid
+        // ^------
+        retval += '^';
+        retval += make_string(reg.after(), '-');
+    }
+    else
+    {
+        // invalid
+        // ~~~~~~~
+        retval += make_string(reg.size(), '~');
+    }
    retval += ' ';
    retval += comment_for_underline;
    if(helps.size() != 0)
@@ -270,7 +321,19 @@ inline std::string format_underline(const std::string& message,
    retval << make_string(line_num_width + 1, ' ');
    retval << " | ";
    retval << make_string(reg1.before(), ' ');
-    retval << make_string(reg1.size(),   '~');
+    if(reg1.size() == 1)
+    {
+        // invalid
+        // ^------
+        retval << '^';
+        retval << make_string(reg1.after(), '-');
+    }
+    else
+    {
+        // invalid
+        // ~~~~~~~
+        retval << make_string(reg1.size(), '~');
+    }
    retval << ' ';
    retval << comment_for_underline1 << newline;
 //  ---------------------------------------
@@ -287,7 +350,19 @@ inline std::string format_underline(const std::string& message,
    retval << make_string(line_num_width + 1, ' ');
    retval << " | ";
    retval << make_string(reg2.before(), ' ');
-    retval << make_string(reg2.size(),   '~');
+    if(reg2.size() == 1)
+    {
+        // invalid
+        // ^------
+        retval << '^';
+        retval << make_string(reg2.after(), '-');
+    }
+    else
+    {
+        // invalid
+        // ~~~~~~~
+        retval << make_string(reg2.size(), '~');
+    }
    retval << ' ';
    retval << comment_for_underline2;
    if(helps.size() != 0)
@@ -305,62 +380,84 @@ inline std::string format_underline(const std::string& message,
    return retval.str();
 }

-
 // to show a better error message.
-template<typename Container>
-std::string
-format_underline(const std::string& message, const location<Container>& loc,
-                 const std::string& comment_for_underline,
-                 std::vector<std::string> helps = {})
+inline std::string format_underline(const std::string& message,
+        std::vector<std::pair<region_base const*, std::string>> reg_com,
+        std::vector<std::string> helps = {})
 {
+    assert(!reg_com.empty());
+
 #ifdef _WIN32
    const auto newline = "\r\n";
 #else
    const char newline = '\n';
 #endif
-    using const_iterator   = typename location<Container>::const_iterator;
-    using reverse_iterator = std::reverse_iterator<const_iterator>;
-    const auto line_begin  = std::find(reverse_iterator(loc.iter()),
-                                       reverse_iterator(loc.begin()),
-                                       '\n').base();
-    const auto line_end    = std::find(loc.iter(), loc.end(), '\n');

-    const auto line_number = std::to_string(
-            1 + std::count(loc.begin(), loc.iter(), '\n'));
+    const auto line_num_width = std::max_element(reg_com.begin(), reg_com.end(),
+        [](std::pair<region_base const*, std::string> const& lhs,
+           std::pair<region_base const*, std::string> const& rhs)
+        {
+            return lhs.first->line_num().size() < rhs.first->line_num().size();
+        }
+    )->first->line_num().size();
+
+    std::ostringstream retval;
+    retval << message << newline;
+
+    for(std::size_t i=0; i<reg_com.size(); ++i)
+    {
+        if(i!=0 && reg_com.at(i-1).first->name() == reg_com.at(i).first->name())
+        {
+            retval << " ..." << newline;
+        }
+        else
+        {
+            retval << " --> " << reg_com.at(i).first->name() << newline;
+        }
+
+        const region_base* const reg = reg_com.at(i).first;
+        const std::string&   comment = reg_com.at(i).second;
+
+
+        retval << ' ' << std::setw(line_num_width) << reg->line_num();
+        retval << " | " << reg->line() << newline;
+        retval << make_string(line_num_width + 1, ' ');
+        retval << " | " << make_string(reg->before(), ' ');
+
+        if(reg->size() == 1)
+        {
+            // invalid
+            // ^------
+            retval << '^';
+            retval << make_string(reg->after(), '-');
+        }
+        else
+        {
+            // invalid
+            // ~~~~~~~
+            retval << make_string(reg->size(), '~');
+        }
+
+        retval << ' ';
+        retval << comment << newline;
+    }

-    std::string retval;
-    retval += message;
-    retval += newline;
-    retval += " --> ";
-    retval += loc.name();
-    retval += newline;
-    retval += ' ';
-    retval += line_number;
-    retval += " | ";
-    retval += make_string(line_begin, line_end);
-    retval += newline;
-    retval += make_string(line_number.size() + 1, ' ');
-    retval += " | ";
-    retval += make_string(std::distance(line_begin, loc.iter()),' ');
-    retval += '^';
-    retval += make_string(std::distance(loc.iter(), line_end), '-');
-    retval += ' ';
-    retval += comment_for_underline;
    if(helps.size() != 0)
    {
-        retval += newline;
-        retval += make_string(line_number.size() + 1, ' ');
-        retval += " | ";
+        retval << newline;
+        retval << make_string(line_num_width + 1, ' ');
+        retval << " | ";
        for(const auto help : helps)
        {
-            retval += newline;
-            retval += "Hint: ";
-            retval += help;
+            retval << newline;
+            retval << "Hint: ";
+            retval << help;
        }
    }
-    return retval;
+    return retval.str();
 }

+
 } // detail
 } // toml
 #endif// TOML11_REGION_H
--- a/toml/result.hpp
+++ b/toml/result.hpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT License.
 #ifndef TOML11_RESULT_H
 #define TOML11_RESULT_H
+#include "traits.hpp"
 #include <type_traits>
 #include <stdexcept>
 #include <utility>
@@ -13,19 +14,6 @@
 namespace toml
 {

-#if __cplusplus >= 201703L
-
-template<typename F, typename ... Args>
-using return_type_of_t = std::invoke_result_t<F, Args...>;
-
-#else
-// result_of is deprecated after C++17
-template<typename F, typename ... Args>
-using return_type_of_t = typename std::result_of<F(Args...)>::type;
-
-#endif
-
-
 template<typename T>
 struct success
 {
@@ -441,21 +429,21 @@ struct result
    // F: T -> U
    // retval: result<U, E>
    template<typename F>
-    result<return_type_of_t<F, value_type&>, error_type>
+    result<detail::return_type_of_t<F, value_type&>, error_type>
    map(F&& f) &
    {
        if(this->is_ok()){return ok(f(this->as_ok()));}
        return err(this->as_err());
    }
    template<typename F>
-    result<return_type_of_t<F, value_type const&>, error_type>
+    result<detail::return_type_of_t<F, value_type const&>, error_type>
    map(F&& f) const&
    {
        if(this->is_ok()){return ok(f(this->as_ok()));}
        return err(this->as_err());
    }
    template<typename F>
-    result<return_type_of_t<F, value_type &&>, error_type>
+    result<detail::return_type_of_t<F, value_type &&>, error_type>
    map(F&& f) &&
    {
        if(this->is_ok()){return ok(f(std::move(this->as_ok())));}
@@ -466,21 +454,21 @@ struct result
    // F: E -> F
    // retval: result<T, F>
    template<typename F>
-    result<value_type, return_type_of_t<F, error_type&>>
+    result<value_type, detail::return_type_of_t<F, error_type&>>
    map_err(F&& f) &
    {
        if(this->is_err()){return err(f(this->as_err()));}
        return ok(this->as_ok());
    }
    template<typename F>
-    result<value_type, return_type_of_t<F, error_type const&>>
+    result<value_type, detail::return_type_of_t<F, error_type const&>>
    map_err(F&& f) const&
    {
        if(this->is_err()){return err(f(this->as_err()));}
        return ok(this->as_ok());
    }
    template<typename F>
-    result<value_type, return_type_of_t<F, error_type&&>>
+    result<value_type, detail::return_type_of_t<F, error_type&&>>
    map_err(F&& f) &&
    {
        if(this->is_err()){return err(f(std::move(this->as_err())));}
@@ -491,21 +479,21 @@ struct result
    // F: T -> U
    // retval: U
    template<typename F, typename U>
-    return_type_of_t<F, value_type&>
+    detail::return_type_of_t<F, value_type&>
    map_or_else(F&& f, U&& opt) &
    {
        if(this->is_err()){return std::forward<U>(opt);}
        return f(this->as_ok());
    }
    template<typename F, typename U>
-    return_type_of_t<F, value_type const&>
+    detail::return_type_of_t<F, value_type const&>
    map_or_else(F&& f, U&& opt) const&
    {
        if(this->is_err()){return std::forward<U>(opt);}
        return f(this->as_ok());
    }
    template<typename F, typename U>
-    return_type_of_t<F, value_type&&>
+    detail::return_type_of_t<F, value_type&&>
    map_or_else(F&& f, U&& opt) &&
    {
        if(this->is_err()){return std::forward<U>(opt);}
@@ -516,21 +504,21 @@ struct result
    // F: E -> U
    // retval: U
    template<typename F, typename U>
-    return_type_of_t<F, error_type&>
+    detail::return_type_of_t<F, error_type&>
    map_err_or_else(F&& f, U&& opt) &
    {
        if(this->is_ok()){return std::forward<U>(opt);}
        return f(this->as_err());
    }
    template<typename F, typename U>
-    return_type_of_t<F, error_type const&>
+    detail::return_type_of_t<F, error_type const&>
    map_err_or_else(F&& f, U&& opt) const&
    {
        if(this->is_ok()){return std::forward<U>(opt);}
        return f(this->as_err());
    }
    template<typename F, typename U>
-    return_type_of_t<F, error_type&&>
+    detail::return_type_of_t<F, error_type&&>
    map_err_or_else(F&& f, U&& opt) &&
    {
        if(this->is_ok()){return std::forward<U>(opt);}
@@ -542,21 +530,21 @@ struct result
    // toml::err(error_type) should be convertible to U.
    // normally, type U is another result<S, F> and E is convertible to F
    template<typename F>
-    return_type_of_t<F, value_type&>
+    detail::return_type_of_t<F, value_type&>
    and_then(F&& f) &
    {
        if(this->is_ok()){return f(this->as_ok());}
        return err(this->as_err());
    }
    template<typename F>
-    return_type_of_t<F, value_type const&>
+    detail::return_type_of_t<F, value_type const&>
    and_then(F&& f) const&
    {
        if(this->is_ok()){return f(this->as_ok());}
        return err(this->as_err());
    }
    template<typename F>
-    return_type_of_t<F, value_type&&>
+    detail::return_type_of_t<F, value_type&&>
    and_then(F&& f) &&
    {
        if(this->is_ok()){return f(std::move(this->as_ok()));}
@@ -568,21 +556,21 @@ struct result
    // toml::ok(value_type) should be convertible to U.
    // normally, type U is another result<S, F> and T is convertible to S
    template<typename F>
-    return_type_of_t<F, error_type&>
+    detail::return_type_of_t<F, error_type&>
    or_else(F&& f) &
    {
        if(this->is_err()){return f(this->as_err());}
        return ok(this->as_ok());
    }
    template<typename F>
-    return_type_of_t<F, error_type const&>
+    detail::return_type_of_t<F, error_type const&>
    or_else(F&& f) const&
    {
        if(this->is_err()){return f(this->as_err());}
        return ok(this->as_ok());
    }
    template<typename F>
-    return_type_of_t<F, error_type&&>
+    detail::return_type_of_t<F, error_type&&>
    or_else(F&& f) &&
    {
        if(this->is_err()){return f(std::move(this->as_err()));}
--- a/toml/serializer.hpp
+++ b/toml/serializer.hpp
@@ -0,0 +1,511 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_SERIALIZER_HPP
+#define TOML11_SERIALIZER_HPP
+#include "value.hpp"
+#include "lexer.hpp"
+#include <limits>
+
+namespace toml
+{
+
+struct serializer
+{
+    serializer(const std::size_t w              = 80,
+               const int         float_prec     = std::numeric_limits<toml::floating>::max_digits10,
+               const bool        can_be_inlined = false,
+               std::vector<toml::key> ks        = {})
+        : can_be_inlined_(can_be_inlined), float_prec_(float_prec), width_(w),
+          keys_(std::move(ks))
+    {}
+    ~serializer() = default;
+
+    std::string operator()(const toml::boolean& b) const
+    {
+        return b ? "true" : "false";
+    }
+    std::string operator()(const integer i) const
+    {
+        return std::to_string(i);
+    }
+    std::string operator()(const toml::floating f) const
+    {
+        std::string token = [=] {
+            // every float value needs decimal point (or exponent).
+            std::ostringstream oss;
+            oss << std::setprecision(float_prec_) << std::showpoint << f;
+            return oss.str();
+        }();
+
+        if(token.back() == '.') // 1. => 1.0
+        {
+            token += '0';
+        }
+        const auto e = std::find_if(token.cbegin(), token.cend(),
+            [](const char c) -> bool {
+                return c == 'E' || c == 'e';
+            });
+        if(e == token.cend())
+        {
+            return token; // there is no exponent part. just return it.
+        }
+
+        // zero-prefix in an exponent is not allowed in TOML.
+        // remove it if it exists.
+        bool        sign_exists = false;
+        std::size_t zero_prefix = 0;
+        for(auto iter = std::next(e), iend = token.cend(); iter != iend; ++iter)
+        {
+            if(*iter == '+' || *iter == '-'){sign_exists = true; continue;}
+            if(*iter == '0'){zero_prefix += 1;}
+            else {break;}
+        }
+        if(zero_prefix != 0)
+        {
+            const auto offset = std::distance(token.cbegin(), e) +
+                               (sign_exists ? 2 : 1);
+            token.erase(offset, zero_prefix);
+        }
+        return token;
+    }
+    std::string operator()(const string& s) const
+    {
+        if(s.kind == string_t::basic)
+        {
+            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend())
+            {
+                // if linefeed is contained, make it multiline-string.
+                const std::string open("\"\"\"\n");
+                const std::string close("\\\n\"\"\"");
+                return open + this->escape_ml_basic_string(s.str) + close;
+            }
+
+            // no linefeed. try to make it oneline-string.
+            std::string oneline = this->escape_basic_string(s.str);
+            if(oneline.size() + 2 < width_ || width_ < 2)
+            {
+                const std::string quote("\"");
+                return quote + oneline + quote;
+            }
+
+            // the line is too long compared to the specified width.
+            // split it into multiple lines.
+            std::string token("\"\"\"\n");
+            while(!oneline.empty())
+            {
+                if(oneline.size() < width_)
+                {
+                    token += oneline;
+                    oneline.clear();
+                }
+                else if(oneline.at(width_-2) == '\\')
+                {
+                    token += oneline.substr(0, width_-2);
+                    token += "\\\n";
+                    oneline.erase(0, width_-2);
+                }
+                else
+                {
+                    token += oneline.substr(0, width_-1);
+                    token += "\\\n";
+                    oneline.erase(0, width_-1);
+                }
+            }
+            return token + std::string("\\\n\"\"\"");
+        }
+        else // the string `s` is literal-string.
+        {
+            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() ||
+               std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() )
+            {
+                const std::string open("'''\n");
+                const std::string close("'''");
+                return open + s.str + close;
+            }
+            else
+            {
+                const std::string quote("'");
+                return quote + s.str + quote;
+            }
+        }
+    }
+
+    std::string operator()(const local_date& d) const
+    {
+        std::ostringstream oss;
+        oss << d;
+        return oss.str();
+    }
+    std::string operator()(const local_time& t) const
+    {
+        std::ostringstream oss;
+        oss << t;
+        return oss.str();
+    }
+    std::string operator()(const local_datetime& dt) const
+    {
+        std::ostringstream oss;
+        oss << dt;
+        return oss.str();
+    }
+    std::string operator()(const offset_datetime& odt) const
+    {
+        std::ostringstream oss;
+        oss << odt;
+        return oss.str();
+    }
+
+    std::string operator()(const array& v) const
+    {
+        if(!v.empty() && v.front().is(value_t::Table))// v is an array of tables
+        {
+            // if it's not inlined, we need to add `[[table.key]]`.
+            // but if it can be inlined, we need `table.key = [...]`.
+            if(this->can_be_inlined_)
+            {
+                std::string token;
+                if(!keys_.empty())
+                {
+                    token += this->serialize_key(keys_.back());
+                    token += " = ";
+                }
+                bool width_exceeds = false;
+                token += "[\n";
+                for(const auto& item : v)
+                {
+                    const auto t =
+                        this->make_inline_table(item.cast<value_t::Table>());
+
+                    if(t.size() + 1 > width_ || // +1 for the last comma {...},
+                       std::find(t.cbegin(), t.cend(), '\n') != t.cend())
+                    {
+                        width_exceeds = true;
+                        break;
+                    }
+                    token += t;
+                    token += ",\n";
+                }
+                if(!width_exceeds)
+                {
+                    token += "]\n";
+                    return token;
+                }
+                // if width_exceeds, serialize it as [[array.of.tables]].
+            }
+
+            std::string token;
+            for(const auto& item : v)
+            {
+                token += "[[";
+                token += this->serialize_dotted_key(keys_);
+                token += "]]\n";
+                token += this->make_multiline_table(item.cast<value_t::Table>());
+            }
+            return token;
+        }
+        if(v.empty())
+        {
+            return std::string("[]");
+        }
+
+        // not an array of tables. normal array. first, try to make it inline.
+        {
+            const auto inl = this->make_inline_array(v);
+            if(inl.size() < this->width_ &&
+               std::find(inl.cbegin(), inl.cend(), '\n') == inl.cend())
+            {
+                return inl;
+            }
+        }
+
+        // if the length exceeds this->width_, print multiline array
+        std::string token;
+        std::string current_line;
+        token += "[\n";
+        for(const auto& item : v)
+        {
+            auto next_elem = toml::visit(*this, item);
+            // newline between array-value and comma is not allowed
+            if(next_elem.back() == '\n'){next_elem.pop_back();}
+
+            if(current_line.size() + next_elem.size() + 1 < this->width_)
+            {
+                current_line += next_elem;
+                current_line += ',';
+            }
+            else if(current_line.empty())
+            {
+                // the next elem cannot be within the width.
+                token += next_elem;
+                token += ",\n";
+                // keep current line empty
+            }
+            else // current_line has some tokens and it exceeds width
+            {
+                assert(current_line.back() == ',');
+                token += current_line;
+                token += '\n';
+                current_line = next_elem;
+                current_line += ',';
+            }
+        }
+        if(!current_line.empty())
+        {
+            if(current_line.back() != '\n') {current_line += '\n';}
+            token += current_line;
+        }
+        token += "]\n";
+        return token;
+    }
+
+    std::string operator()(const table& v) const
+    {
+        if(this->can_be_inlined_)
+        {
+            std::string token;
+            if(!this->keys_.empty())
+            {
+                token += this->serialize_key(this->keys_.back());
+                token += " = ";
+            }
+            token += this->make_inline_table(v);
+            if(token.size() < this->width_)
+            {
+                return token;
+            }
+        }
+
+        std::string token;
+        if(!keys_.empty())
+        {
+            token += '[';
+            token += this->serialize_dotted_key(keys_);
+            token += "]\n";
+        }
+        token += this->make_multiline_table(v);
+        return token;
+    }
+
+  private:
+
+    std::string serialize_key(const toml::key& key) const
+    {
+        detail::location<toml::key> loc(key, key);
+        detail::lex_unquoted_key::invoke(loc);
+        if(loc.iter() == loc.end())
+        {
+            return key; // all the tokens are consumed. the key is unquoted-key.
+        }
+        std::string token("\"");
+        token += this->escape_basic_string(key);
+        token += "\"";
+        return token;
+    }
+
+    std::string serialize_dotted_key(const std::vector<toml::key>& keys) const
+    {
+        std::string token;
+        if(keys.empty()){return token;}
+
+        for(const auto& k : keys)
+        {
+            token += this->serialize_key(k);
+            token += '.';
+        }
+        token.erase(token.size() - 1, 1); // remove trailing `.`
+        return token;
+    }
+
+    std::string escape_basic_string(const std::string& s) const
+    {
+        //XXX assuming `s` is a valid utf-8 sequence.
+        std::string retval;
+        for(const char c : s)
+        {
+            switch(c)
+            {
+                case '\\': {retval += "\\\\"; break;}
+                case '\"': {retval += "\\\""; break;}
+                case '\b': {retval += "\\b";  break;}
+                case '\t': {retval += "\\t";  break;}
+                case '\f': {retval += "\\f";  break;}
+                case '\n': {retval += "\\n";  break;}
+                case '\r': {retval += "\\r";  break;}
+                default  : {retval += c;      break;}
+            }
+        }
+        return retval;
+    }
+
+    std::string escape_ml_basic_string(const std::string& s) const
+    {
+        std::string retval;
+        for(auto i=s.cbegin(), e=s.cend(); i!=e; ++i)
+        {
+            switch(*i)
+            {
+                case '\\': {retval += "\\\\"; break;}
+                case '\"': {retval += "\\\""; break;}
+                case '\b': {retval += "\\b";  break;}
+                case '\t': {retval += "\\t";  break;}
+                case '\f': {retval += "\\f";  break;}
+                case '\n': {retval += "\n";   break;}
+                case '\r':
+                {
+                    if(std::next(i) != e && *std::next(i) == '\n')
+                    {
+                        retval += "\r\n";
+                        ++i;
+                    }
+                    else
+                    {
+                        retval += "\\r";
+                    }
+                    break;
+                }
+                default: {retval += *i; break;}
+            }
+        }
+        return retval;
+    }
+
+    std::string make_inline_array(const array& v) const
+    {
+        std::string token;
+        token += '[';
+        bool is_first = true;
+        for(const auto& item : v)
+        {
+            if(is_first) {is_first = false;} else {token += ',';}
+            token += visit(serializer(std::numeric_limits<std::size_t>::max(),
+                                      this->float_prec_, true), item);
+        }
+        token += ']';
+        return token;
+    }
+
+    std::string make_inline_table(const table& v) const
+    {
+        assert(this->can_be_inlined_);
+        std::string token;
+        token += '{';
+        bool is_first = true;
+        for(const auto& kv : v)
+        {
+            // in inline tables, trailing comma is not allowed (toml-lang #569).
+            if(is_first) {is_first = false;} else {token += ',';}
+            token += this->serialize_key(kv.first);
+            token += '=';
+            token += visit(serializer(std::numeric_limits<std::size_t>::max(),
+                                      this->float_prec_, true), kv.second);
+        }
+        token += '}';
+        return token;
+    }
+
+    std::string make_multiline_table(const table& v) const
+    {
+        std::string token;
+
+        // print non-table stuff first. because after printing [foo.bar], the
+        // remaining non-table values will be assigned into [foo.bar], not [foo]
+        for(const auto kv : v)
+        {
+            if(kv.second.is(value_t::Table) || is_array_of_tables(kv.second))
+            {
+                continue;
+            }
+
+            const auto key_and_sep    = this->serialize_key(kv.first) + " = ";
+            const auto residual_width = (this->width_ > key_and_sep.size()) ?
+                                        this->width_ - key_and_sep.size() : 0;
+            token += key_and_sep;
+            token += visit(serializer(residual_width, this->float_prec_, true),
+                           kv.second);
+            if(token.back() != '\n')
+            {
+                token += '\n';
+            }
+        }
+
+        // normal tables / array of tables
+
+        // after multiline table appeared, the other tables cannot be inline
+        // because the table would be assigned into the table.
+        // [foo]
+        // ...
+        // bar = {...} # <- bar will be a member of [foo].
+        bool multiline_table_printed = false;
+        for(const auto& kv : v)
+        {
+            if(!kv.second.is(value_t::Table) && !is_array_of_tables(kv.second))
+            {
+                continue; // other stuff are already serialized. skip them.
+            }
+
+            std::vector<toml::key> ks(this->keys_);
+            ks.push_back(kv.first);
+
+            auto tmp = visit(serializer(
+                this->width_, this->float_prec_, !multiline_table_printed, ks),
+                kv.second);
+
+            if((!multiline_table_printed) &&
+               std::find(tmp.cbegin(), tmp.cend(), '\n') != tmp.cend())
+            {
+                multiline_table_printed = true;
+            }
+            else
+            {
+                // still inline tables only.
+                tmp += '\n';
+            }
+            token += tmp;
+        }
+        return token;
+    }
+
+    bool is_array_of_tables(const value& v) const
+    {
+        if(!v.is(value_t::Array)) {return false;}
+
+        const auto& a = v.cast<value_t::Array>();
+        return !a.empty() && a.front().is(value_t::Table);
+    }
+
+  private:
+
+    bool        can_be_inlined_;
+    int         float_prec_;
+    std::size_t width_;
+    std::vector<toml::key> keys_;
+};
+
+inline std::string
+format(const value& v, std::size_t w = 80,
+       int fprec = std::numeric_limits<toml::floating>::max_digits10)
+{
+    return visit(serializer(w, fprec, true), v);
+}
+inline std::string
+format(const table& t, std::size_t w = 80,
+       int fprec = std::numeric_limits<toml::floating>::max_digits10)
+{
+    return serializer(w, fprec, true)(t);
+}
+
+template<typename charT, typename traits>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const value& v)
+{
+    // get status of std::setw().
+    const std::size_t w     = os.width();
+    const int         fprec = os.precision();
+    os.width(0);
+    // the root object can't be an inline table. so pass `false`.
+    os << visit(serializer(w, fprec, false), v);
+    return os;
+}
+
+} // toml
+#endif// TOML11_SERIALIZER_HPP
--- a/toml/traits.hpp
+++ b/toml/traits.hpp
@@ -15,6 +15,9 @@ namespace detail
 template<typename T>
 using unwrap_t = typename std::decay<T>::type;

+// ---------------------------------------------------------------------------
+// check whether type T is a kind of container/map class
+
 struct has_iterator_impl
 {
    template<typename T> static std::true_type  check(typename T::iterator*);
@@ -63,6 +66,9 @@ struct has_resize_method : decltype(has_resize_method_impl::check<T>(nullptr)){}
 #undef decltype(...)
 #endif

+// ---------------------------------------------------------------------------
+// C++17 and/or/not
+
 template<typename ...> struct conjunction : std::true_type{};
 template<typename T>   struct conjunction<T> : T{};
 template<typename T, typename ... Ts>
@@ -80,6 +86,9 @@ struct disjunction<T, Ts...> :
 template<typename T>
 struct negation : std::integral_constant<bool, !static_cast<bool>(T::value)>{};

+// ---------------------------------------------------------------------------
+// normal type checker
+
 template<typename T> struct is_std_pair : std::false_type{};
 template<typename T1, typename T2>
 struct is_std_pair<std::pair<T1, T2>> : std::true_type{};
@@ -92,7 +101,9 @@ template<typename T> struct is_chrono_duration: std::false_type{};
 template<typename Rep, typename Period>
 struct is_chrono_duration<std::chrono::duration<Rep, Period>>: std::true_type{};

-// to use toml::get<std::tuple<T1, T2, ...>> in C++11
+// ---------------------------------------------------------------------------
+// C++14 index_sequence
+
 template<std::size_t ... Ns> struct index_sequence{};

 template<typename IS, std::size_t N> struct push_back_index_sequence{};
@@ -116,6 +127,21 @@ struct index_sequence_maker<0>
 template<std::size_t N>
 using make_index_sequence = typename index_sequence_maker<N-1>::type;

+// ---------------------------------------------------------------------------
+// return_type_of_t
+
+#if __cplusplus >= 201703L
+
+template<typename F, typename ... Args>
+using return_type_of_t = std::invoke_result_t<F, Args...>;
+
+#else
+// result_of is deprecated after C++17
+template<typename F, typename ... Args>
+using return_type_of_t = typename std::result_of<F(Args...)>::type;
+
+#endif
+
 }// detail
 }//toml
 #endif // TOML_TRAITS
--- a/toml/types.hpp
+++ b/toml/types.hpp
@@ -137,17 +137,6 @@ template<> struct toml_value_t<LocalDate     >{static constexpr value_t value =
 template<> struct toml_value_t<LocalTime     >{static constexpr value_t value = value_t::LocalTime     ;};
 template<> struct toml_value_t<Array         >{static constexpr value_t value = value_t::Array         ;};
 template<> struct toml_value_t<Table         >{static constexpr value_t value = value_t::Table         ;};
-template<typename T> constexpr value_t toml_value_t<T>::value;
-constexpr value_t toml_value_t<Boolean       >::value;
-constexpr value_t toml_value_t<Integer       >::value;
-constexpr value_t toml_value_t<Float         >::value;
-constexpr value_t toml_value_t<String        >::value;
-constexpr value_t toml_value_t<OffsetDatetime>::value;
-constexpr value_t toml_value_t<LocalDatetime >::value;
-constexpr value_t toml_value_t<LocalDate     >::value;
-constexpr value_t toml_value_t<LocalTime     >::value;
-constexpr value_t toml_value_t<Array         >::value;
-constexpr value_t toml_value_t<Table         >::value;

 template<typename T>
 struct is_exact_toml_type : disjunction<
--- a/toml/utility.hpp
+++ b/toml/utility.hpp
@@ -29,8 +29,9 @@ inline void resize_impl(T& container, std::size_t N, std::true_type)
 template<typename T>
 inline void resize_impl(T& container, std::size_t N, std::false_type)
 {
-    if(container.size() >= N) return;
-    else throw std::invalid_argument("not resizable type");
+    if(container.size() >= N) {return;}
+
+    throw std::invalid_argument("not resizable type");
 }

 } // detail
@@ -38,8 +39,9 @@ inline void resize_impl(T& container, std::size_t N, std::false_type)
 template<typename T>
 inline void resize(T& container, std::size_t N)
 {
-    if(container.size() == N) return;
-    else return detail::resize_impl(container, N, detail::has_resize_method<T>());
+    if(container.size() == N) {return;}
+
+    return detail::resize_impl(container, N, detail::has_resize_method<T>());
 }

 namespace detail
@@ -73,7 +75,5 @@ T from_string(const std::string& str, U&& opt)
    return v;
 }

-
-
 }// toml
 #endif // TOML11_UTILITY
--- a/toml/value.hpp
+++ b/toml/value.hpp
@@ -21,8 +21,8 @@ namespace detail
 {
 // to show error messages. not recommended for users.
 region_base const& get_region(const value&);
-// ditto.
-void assign_keeping_region(value&, value);
+template<typename Region>
+void change_region(value&, Region&&);
 }// detail

 template<typename T>
@@ -562,8 +562,8 @@ class value
    // for error messages
    friend region_base const& detail::get_region(const value&);

-    // to see why it's here, see detail::insert_nested_key.
-    friend void detail::assign_keeping_region(value&, value);
+    template<typename Region>
+    friend void detail::change_region(value&, Region&&);

    template<value_t T>
    struct switch_cast;
@@ -599,35 +599,21 @@ inline region_base const& get_region(const value& v)
 {
    return *(v.region_info_);
 }
-// If we keep region information after assigning another toml::* types, the
-// error message become different from the actual value contained.
-// To avoid this kind of confusing phenomena, the default assigners clear the
-// old region_info_. But this functionality is actually needed deep inside of
-// parser, so if you want to see the usecase, see toml::detail::insert_nested_key
-// defined in toml/parser.hpp.
-inline void assign_keeping_region(value& v, value other)
+
+template<typename Region>
+void change_region(value& v, Region&& reg)
 {
-    v.cleanup(); // this keeps region info
-    // keep region_info_ intact
-    v.type_ = other.type();
-    switch(v.type())
-    {
-        case value_t::Boolean       : ::toml::value::assigner(v.boolean_        , other.boolean_        ); break;
-        case value_t::Integer       : ::toml::value::assigner(v.integer_        , other.integer_        ); break;
-        case value_t::Float         : ::toml::value::assigner(v.floating_       , other.floating_       ); break;
-        case value_t::String        : ::toml::value::assigner(v.string_         , other.string_         ); break;
-        case value_t::OffsetDatetime: ::toml::value::assigner(v.offset_datetime_, other.offset_datetime_); break;
-        case value_t::LocalDatetime : ::toml::value::assigner(v.local_datetime_ , other.local_datetime_ ); break;
-        case value_t::LocalDate     : ::toml::value::assigner(v.local_date_     , other.local_date_     ); break;
-        case value_t::LocalTime     : ::toml::value::assigner(v.local_time_     , other.local_time_     ); break;
-        case value_t::Array         : ::toml::value::assigner(v.array_          , other.array_          ); break;
-        case value_t::Table         : ::toml::value::assigner(v.table_          , other.table_          ); break;
-        default: break;
-    }
+    using region_type = typename std::remove_reference<
+        typename std::remove_cv<Region>::type
+        >::type;
+
+    std::shared_ptr<region_base> new_reg =
+        std::make_shared<region_type>(std::forward<region_type>(reg));
+    v.region_info_ = new_reg;
    return;
 }
-}// detail

+}// detail

 template<> struct value::switch_cast<value_t::Boolean>
 {
@@ -767,6 +753,8 @@ inline bool operator<(const toml::value& lhs, const toml::value& rhs)
            return lhs.cast<value_t::Float   >() < rhs.cast<value_t::Float   >();
        case value_t::String  :
            return lhs.cast<value_t::String  >() < rhs.cast<value_t::String  >();
+        case value_t::OffsetDatetime:
+            return lhs.cast<value_t::OffsetDatetime>() < rhs.cast<value_t::OffsetDatetime>();
        case value_t::LocalDatetime:
            return lhs.cast<value_t::LocalDatetime>() < rhs.cast<value_t::LocalDatetime>();
        case value_t::LocalDate:
@@ -818,5 +806,77 @@ inline std::string format_error(const std::string& err_msg,
                                             std::move(hints));
 }

+template<typename Visitor>
+detail::return_type_of_t<Visitor, const toml::boolean&>
+visit(Visitor&& visitor, const toml::value& v)
+{
+    switch(v.type())
+    {
+        case value_t::Boolean       : {return visitor(v.cast<value_t::Boolean       >());}
+        case value_t::Integer       : {return visitor(v.cast<value_t::Integer       >());}
+        case value_t::Float         : {return visitor(v.cast<value_t::Float         >());}
+        case value_t::String        : {return visitor(v.cast<value_t::String        >());}
+        case value_t::OffsetDatetime: {return visitor(v.cast<value_t::OffsetDatetime>());}
+        case value_t::LocalDatetime : {return visitor(v.cast<value_t::LocalDatetime >());}
+        case value_t::LocalDate     : {return visitor(v.cast<value_t::LocalDate     >());}
+        case value_t::LocalTime     : {return visitor(v.cast<value_t::LocalTime     >());}
+        case value_t::Array         : {return visitor(v.cast<value_t::Array         >());}
+        case value_t::Table         : {return visitor(v.cast<value_t::Table         >());}
+        case value_t::Empty         : break;
+        case value_t::Unknown       : break;
+        default: break;
+    }
+    throw std::runtime_error(format_error("[error] toml::visit: toml::value "
+            "does not have any valid value.", v, "here"));
+}
+
+template<typename Visitor>
+detail::return_type_of_t<Visitor, toml::boolean&>
+visit(Visitor&& visitor, toml::value& v)
+{
+    switch(v.type())
+    {
+        case value_t::Boolean       : {return visitor(v.cast<value_t::Boolean       >());}
+        case value_t::Integer       : {return visitor(v.cast<value_t::Integer       >());}
+        case value_t::Float         : {return visitor(v.cast<value_t::Float         >());}
+        case value_t::String        : {return visitor(v.cast<value_t::String        >());}
+        case value_t::OffsetDatetime: {return visitor(v.cast<value_t::OffsetDatetime>());}
+        case value_t::LocalDatetime : {return visitor(v.cast<value_t::LocalDatetime >());}
+        case value_t::LocalDate     : {return visitor(v.cast<value_t::LocalDate     >());}
+        case value_t::LocalTime     : {return visitor(v.cast<value_t::LocalTime     >());}
+        case value_t::Array         : {return visitor(v.cast<value_t::Array         >());}
+        case value_t::Table         : {return visitor(v.cast<value_t::Table         >());}
+        case value_t::Empty         : break;
+        case value_t::Unknown       : break;
+        default: break;
+    }
+    throw std::runtime_error(format_error("[error] toml::visit: toml::value "
+            "does not have any valid value.", v, "here"));
+}
+
+template<typename Visitor>
+detail::return_type_of_t<Visitor, toml::boolean&>
+visit(Visitor&& visitor, toml::value&& v)
+{
+    switch(v.type())
+    {
+        case value_t::Boolean       : {return visitor(std::move(v.cast<value_t::Boolean       >()));}
+        case value_t::Integer       : {return visitor(std::move(v.cast<value_t::Integer       >()));}
+        case value_t::Float         : {return visitor(std::move(v.cast<value_t::Float         >()));}
+        case value_t::String        : {return visitor(std::move(v.cast<value_t::String        >()));}
+        case value_t::OffsetDatetime: {return visitor(std::move(v.cast<value_t::OffsetDatetime>()));}
+        case value_t::LocalDatetime : {return visitor(std::move(v.cast<value_t::LocalDatetime >()));}
+        case value_t::LocalDate     : {return visitor(std::move(v.cast<value_t::LocalDate     >()));}
+        case value_t::LocalTime     : {return visitor(std::move(v.cast<value_t::LocalTime     >()));}
+        case value_t::Array         : {return visitor(std::move(v.cast<value_t::Array         >()));}
+        case value_t::Table         : {return visitor(std::move(v.cast<value_t::Table         >()));}
+        case value_t::Empty         : break;
+        case value_t::Unknown       : break;
+        default: break;
+    }
+    throw std::runtime_error(format_error("[error] toml::visit: toml::value "
+            "does not have any valid value.", v, "here"));
+}
+
 }// toml
 #endif// TOML11_VALUE
Author	SHA1	Message	Date
Toru Niina	f5079a7892	Merge pull request #32 from ToruNiina/allow-deeper-table-before Allow deeper table before	2019-03-06 12:03:14 +09:00
ToruNiina	d90ffb63c6	Merge branch 'master' into allow-deeper-table-before	2019-03-05 23:27:11 +09:00
ToruNiina	b0ed122214	fix: allow deeper table appeared before allow the following toml file. ```toml [a.b.c] d = 10 [a] e = 2.718 ```	2019-03-05 23:25:25 +09:00
ToruNiina	d88521d63c	feat: enable to change region of value To allow the following toml file, we need to replace the region after the more precise region is found. ```toml [a.b.c] d = 42 [a] e = 2.71 ``` If the precise region (here, [a]) is found, the region of `a` should be `[a]`, not `[a.b.c]`. After `[a]` is defined, toml does not allow to write `[a]` twice. To check it, we need to replace the region of values to the precise one.	2019-03-04 15:01:28 +09:00
ToruNiina	2accc9d22c	fix: diagnose, but not throw for unicode error in 2.0.x and 2.1.0, README says "it shows warning" for invalid unicode codepoints. So far, this library just show an error message in stderr for this case. It is not good to change the behavior fatal in the next minor release, 2.1.1, that includes patches and improved error msgs. I will make it throw syntax_error after 2.2.0 for invalid unicode codepoints. For now, I will keep it to be "warning".	2019-03-03 18:56:45 +09:00
Toru Niina	363927f489	Merge pull request #31 from ToruNiina/err-msg-inhomogenous-array improve error messages for invalid arrays	2019-03-02 23:07:29 +09:00
ToruNiina	ae793fb631	feat: improve error message for invalid array	2019-03-02 17:56:16 +09:00
ToruNiina	944b83642a	feat: make location to inherit region_base To generate error message, it is better to have the same interface. Also, location can be considered as a region having only one character.	2019-03-02 17:52:00 +09:00
Toru Niina	5a8e5dee73	Merge pull request #30 from ToruNiina/hotfix small patches for parser	2019-03-02 16:11:31 +09:00
ToruNiina	7f870d5861	fix: diagnose invalid UTF-8 codepoints	2019-03-02 01:57:05 +09:00
ToruNiina	536b23dc84	fix: allow empty table in the middle of a file	2019-03-01 22:53:16 +09:00
ToruNiina	0c9806e99f	fix: diagnose key after [table.key] pattern the following is not a valid toml format. ``` [table] key = "value" ``` this commit enables to diagnose that pattern.	2019-03-01 22:37:52 +09:00
ToruNiina	5a92932019	fix: disallow invalid escape sequence	2019-03-01 22:13:32 +09:00
ToruNiina	e929d2f00f	fix: allow empty input file (to be an empty table)	2019-02-27 12:30:57 +09:00
Toru Niina	1e1e4c06e8	Merge pull request #29 from ToruNiina/err-msg-dotted-key Error message for getting values corresponds to dotted keys	2019-02-27 12:21:03 +09:00
ToruNiina	d0726db473	chore: merge branch master into err-msg-dotted-key	2019-02-27 01:26:36 +09:00
Toru Niina	4cdc15a824	Merge pull request #28 from xaxousis/master Add location to error string in parse_* functions	2019-02-27 01:25:52 +09:00
ToruNiina	b36fdf2f54	refactor: remove internal fn not needed any more The function was needed to copy region information from value to value, for a useful error message. Because of the last few commits, the region information about keys are passed to insert_nested_keys that requires the function which is removed. And it turned out that the function is no longer required. It is originally a workaround, so I removed it.	2019-02-27 01:07:00 +09:00
ToruNiina	73ba6b385f	feat: use key-region to represent table use x.y.z = 42 ~~~ here as the region of the table `x.y`	2019-02-27 01:02:39 +09:00
ToruNiina	30d1639aa4	refactor: return region info from parse_kvpair	2019-02-27 00:21:05 +09:00
Quentin Khan	d82814fc86	Add location to error string in parse_* functions	2019-02-26 14:56:58 +01:00
ToruNiina	2220efd682	chore: show appvayor status of master branch other branches might be unstable, so they might fail. It is good to show the status of the stable branch, rather than the experimental branches.	2019-02-26 00:26:04 +09:00
ToruNiina	679b365cf7	feat: get region info when parsing keys Error messages related to dotted keys looks weird. like: 1 \| a.b.c = 42 \| ~~ in this table The underlined token is not a table. This should be like the following. 1 \| a.b.c = 42 \| ~~~ in this table To implement this, the region information is needed when the keys are read. This commit add this functionality, though currently the region information is not used yet.	2019-02-26 00:17:28 +09:00
ToruNiina	83bf83b6dd	style: add braces to if and remove additional else	2019-02-19 02:56:15 +09:00
ToruNiina	321364c7c2	fix: format char in an error message correctly	2019-02-19 02:46:48 +09:00
ToruNiina	d8707d5867	chore: fix README	2019-02-17 00:22:19 +09:00
ToruNiina	2dd0a78c52	fix: reset stream width before printing without this, the first line of the serialized result becomes too wide	2019-02-16 23:55:19 +09:00
Toru Niina	d7b8c3c78f	Merge pull request #18 from ToruNiina/threadsafe-localtime add threadsafe localtime_(s\|r)	2019-02-16 23:28:48 +09:00
Toru Niina	2f0148a2df	Merge pull request #26 from ToruNiina/serialize add serializer	2019-02-16 23:27:05 +09:00
ToruNiina	4accc29984	chore: update README	2019-02-14 16:47:15 +09:00
ToruNiina	19b9af2494	Merge branch 'master' into serialize	2019-02-14 16:34:45 +09:00
ToruNiina	0aa50e9439	style: just add newlines to README	2019-02-14 16:26:48 +09:00
ToruNiina	a00a906482	fix: add comma at correct position	2019-02-14 16:17:32 +09:00
ToruNiina	19ad7d7c96	fix: remove needless empty line from serialization	2019-02-14 16:17:04 +09:00
ToruNiina	251e55da42	fix: don't ignore std::setw(0)	2019-02-14 15:49:27 +09:00
ToruNiina	32f1b2060a	fix: avoid width overflow	2019-02-14 15:49:13 +09:00
ToruNiina	b1c54532df	feat: improve array serialization - make multiline array more clean - short-circuit for empty array	2019-02-14 15:48:05 +09:00
ToruNiina	38c67f16e8	fix: initialize float precition correctly	2019-02-14 15:47:00 +09:00
ToruNiina	24aefc52a1	test: set width in test_serialize	2019-02-14 15:46:12 +09:00
ToruNiina	ba8c205253	fix: change CRLF into LF before comparison	2019-02-13 23:48:53 +09:00
ToruNiina	31193d99ba	Merge branch 'master' into serialize	2019-02-13 23:16:39 +09:00
ToruNiina	c4aecc8e4b	chore: update README badges	2019-02-13 22:36:29 +09:00
Toru Niina	60c81d06a0	Merge pull request #25 from ToruNiina/hotfix fix: open file as binary-mode #16	2019-02-13 21:14:15 +09:00
ToruNiina	46569da231	fix: avoid auto-conversion while making test case	2019-02-13 19:51:54 +09:00
ToruNiina	5e20a8ff16	fix: add scope to the test case to flush	2019-02-13 19:26:52 +09:00
ToruNiina	dd9319245e	fix: open file as binary-mode #16 to avoid inconsistency between file size (obtained by tellg) and the size of the actual contents that would be read later	2019-02-13 19:18:09 +09:00
ToruNiina	4bbe42d105	test: add test_serialize_file	2019-02-13 13:51:36 +09:00
ToruNiina	5bdc022627	fix: correctly serialize quoted keys	2019-02-13 13:51:08 +09:00
ToruNiina	41e354f1ee	supress warnings while skipping switch-cases	2019-02-13 13:50:33 +09:00
ToruNiina	d1c76709b0	add serializer #23	2019-02-13 13:37:58 +09:00
ToruNiina	64774a8db0	add toml::visit to use it in serializer	2019-02-13 13:36:55 +09:00
ToruNiina	53f6b8268b	fix: compare offset_datetime correctly	2019-02-13 13:34:26 +09:00
ToruNiina	32dcc35918	move return_type_of_t from result to traits	2019-02-13 13:34:03 +09:00
ToruNiina	8c3854b28b	update README	2019-01-31 15:37:25 +09:00
Toru Niina	75af9c79df	Merge pull request #22 from xaxousis/master Fix multiple definition error	2019-01-31 01:34:33 +09:00
Quentin Khan	1dfe32acd8	Fix multiple definition error	2019-01-30 17:06:23 +01:00
ToruNiina	51dd3abcae	remove one branch by preprocessor since localtime in windows is already thread-safe, there are no need to change the function.	2018-12-26 13:38:01 +09:00
ToruNiina	825b2c30a1	add threadsafe localtime_(s\|r)	2018-12-25 22:40:52 +09:00