Merge pull request #37 from ToruNiina/to-toml-deprecated

feat: mark to_toml as deprecated
2025-12-16 03:08:52 +08:00 · 2019-03-15 17:12:45 +09:00 · 2019-03-15 14:29:32 +09:00 · 2019-03-15 13:41:16 +09:00 · 2019-03-15 12:40:01 +09:00 · 2019-03-15 12:38:37 +09:00
25 changed files with 2542 additions and 628 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,8 +12,39 @@ matrix:
        - ubuntu-toolchain-r-test
        packages:
        - g++-5
-        - build-essential
-        - cmake
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-6"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-6
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-7"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-7
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-8
        - libboost-all-dev
  - os: linux
    language: cpp
@@ -26,8 +57,66 @@ matrix:
        - llvm-toolchain-precise-3.7
        packages:
        - clang-3.7
-        - build-essential
-        - cmake
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-4.0"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-4.0
+        packages:
+        - clang-4.0
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-5.0"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-5.0
+        packages:
+        - clang-5.0
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-6.0"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-6.0
+        packages:
+        - clang-6.0
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-7"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-7
+        packages:
+        - clang-7
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8"
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-8
+        packages:
+        - clang-8
        - libboost-all-dev
  - os: osx
    language: cpp
--- 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/encoder 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.
@@ -446,7 +505,7 @@ if(max < min)
 you will get an error message like this.

 ```console
-[error] value should be positive
+[error] max should be larger than min
 --> example.toml
 3 | min = 54
   |       ~~ minimum number here
@@ -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,9 @@ 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
+  - Improved error message to show the location where the parser fails

 ## Licensing terms

--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -25,8 +25,11 @@ set(TEST_NAMES
    test_to_toml
    test_from_toml
    test_parse_file
+    test_serialize_file
    test_parse_unicode
-    )
+    test_error_detection
+    test_format_error
+)

 CHECK_CXX_COMPILER_FLAG("-Wall" COMPILER_SUPPORTS_WALL)
 CHECK_CXX_COMPILER_FLAG("-Wpedantic" COMPILER_SUPPORTS_WPEDANTIC)
--- a/tests/test_error_detection.cpp
+++ b/tests/test_error_detection.cpp
@@ -0,0 +1,199 @@
+#define BOOST_TEST_MODULE "test_error_detection"
+#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_detect_empty_key)
+{
+    std::istringstream stream(std::string("= \"value\""));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_empty_key");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        // to see the error message
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_missing_value)
+{
+    std::istringstream stream(std::string("a ="));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_missing_value");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_too_many_value)
+{
+    std::istringstream stream(std::string("a = 1 = \"value\""));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_too_many_value");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_duplicate_table)
+{
+    std::istringstream stream(std::string(
+            "[table]\n"
+            "a = 42\n"
+            "[table]\n"
+            "b = 42\n"
+            ));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_duplicate_table");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_conflict_array_table)
+{
+    std::istringstream stream(std::string(
+            "[[table]]\n"
+            "a = 42\n"
+            "[table]\n"
+            "b = 42\n"
+            ));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_conflict_array_table");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_conflict_table_array)
+{
+    std::istringstream stream(std::string(
+            "[table]\n"
+            "a = 42\n"
+            "[[table]]\n"
+            "b = 42\n"
+            ));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_conflict_table_array");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_duplicate_value)
+{
+    std::istringstream stream(std::string(
+            "a = 1\n"
+            "a = 2\n"
+            ));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_duplicate_value");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_conflicting_value)
+{
+    std::istringstream stream(std::string(
+            "a.b   = 1\n"
+            "a.b.c = 2\n"
+            ));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_conflicting_value");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_inhomogeneous_array)
+{
+    std::istringstream stream(std::string(
+            "a = [1, 1.0]\n"
+            ));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_inhomogeneous_array");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
+BOOST_AUTO_TEST_CASE(test_detect_appending_array_of_table)
+{
+    std::istringstream stream(std::string(
+            "a = [{b = 1}]\n"
+            "[[a]]\n"
+            "b = 2\n"
+            ));
+    bool exception_thrown = false;
+    try
+    {
+        toml::parse(stream, "test_detect_appending_array_of_table");
+    }
+    catch(const toml::syntax_error& syn)
+    {
+        std::cerr << syn.what() << std::endl;
+        exception_thrown = true;
+    }
+    BOOST_CHECK(exception_thrown);
+}
+
--- a/tests/test_format_error.cpp
+++ b/tests/test_format_error.cpp
@@ -0,0 +1,75 @@
+#define BOOST_TEST_MODULE "test_value"
+#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>
+
+// to check it successfully compiles. it does not check the formatted string.
+
+BOOST_AUTO_TEST_CASE(test_1_value)
+{
+    toml::value val(42);
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error", val, "this is a value");
+        std::cout << pretty_error << std::endl;
+    }
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error", val, "this is a value",
+                               std::vector<std::string>{"this is a hint"});
+        std::cout << pretty_error << std::endl;
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_2_values)
+{
+    toml::value v1(42);
+    toml::value v2(3.14);
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi");
+        std::cout << pretty_error << std::endl;
+    }
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi",
+                               std::vector<std::string>{"hint"});
+        std::cout << pretty_error << std::endl;
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_3_values)
+{
+    toml::value v1(42);
+    toml::value v2(3.14);
+    toml::value v3("foo");
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi",
+                               v3, "this is a meta-syntactic variable");
+        std::cout << pretty_error << std::endl;
+    }
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi",
+                               v3, "this is a meta-syntactic variable",
+                               std::vector<std::string>{"hint 1", "hint 2"});
+        std::cout << pretty_error << std::endl;
+    }
+}
--- a/tests/test_get_related_func.cpp
+++ b/tests/test_get_related_func.cpp
@@ -68,9 +68,14 @@ BOOST_AUTO_TEST_CASE(test_expect)
    {
        toml::value v1(42);
        toml::value v2(3.14);
-        BOOST_CHECK_EQUAL(42, toml::expect<int>(v1).unwrap_or(0));
-        BOOST_CHECK_EQUAL( 0, toml::expect<int>(v2).unwrap_or(0));
-        BOOST_CHECK_EQUAL("42",   toml::expect<int>(v1).map([](int i){return std::to_string(i);}).unwrap_or(std::string("none")));
-        BOOST_CHECK_EQUAL("none", toml::expect<int>(v2).map([](int i){return std::to_string(i);}).unwrap_or(std::string("none")));
+        const auto v1_or_0 = toml::expect<int>(v1).unwrap_or(0);
+        const auto v2_or_0 = toml::expect<int>(v2).unwrap_or(0);
+        BOOST_CHECK_EQUAL(42, v1_or_0);
+        BOOST_CHECK_EQUAL( 0, v2_or_0);
+
+        const auto v1_or_none = toml::expect<int>(v1).map([](int i){return std::to_string(i);}).unwrap_or(std::string("none"));
+        const auto v2_or_none = toml::expect<int>(v2).map([](int i){return std::to_string(i);}).unwrap_or(std::string("none"));
+        BOOST_CHECK_EQUAL("42",   v1_or_none);
+        BOOST_CHECK_EQUAL("none", v2_or_none);
    }
 }
--- a/tests/test_parse_file.cpp
+++ b/tests/test_parse_file.cpp
@@ -194,3 +194,504 @@ BOOST_AUTO_TEST_CASE(test_hard_example)
    BOOST_CHECK(toml::get<std::vector<std::string>>(bit.at("multi_line_array")) ==
                expected_multi_line_array);
 }
+
+// ---------------------------------------------------------------------------
+// after here, the test codes generate the content of a file.
+
+BOOST_AUTO_TEST_CASE(test_file_with_BOM)
+{
+    {
+        const std::string table(
+            "\xEF\xBB\xBF" // BOM
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss, "test_file_with_BOM.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\"\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
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            );
+        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");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_file_without_newline_at_the_end_of_file)
+{
+    {
+        const std::string table(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\""
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_file_without_newline_at_the_end_of_file.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\""
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_file_without_newline_at_the_end_of_file_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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\" # comment"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_file_without_newline_at_the_end_of_file_comment.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\" # comment"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_file_without_newline_at_the_end_of_file_comment.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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\" \t"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_file_without_newline_at_the_end_of_file_ws.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\" \t"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_file_without_newline_at_the_end_of_file_ws.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE(test_files_end_with_comment)
+{
+    // comment w/o newline
+    {
+        const std::string table(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "# comment"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "# comment\n"
+            "# one more comment"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+
+    // comment w/ newline
+
+    {
+        const std::string table(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "# comment\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "# comment\n"
+            "# one more comment\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+
+    // CRLF version
+
+    {
+        const std::string table(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "# comment"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "# comment\r\n"
+            "# one more comment"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "# comment\r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "# comment\r\n"
+            "# one more comment\r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_comment.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
+{
+    {
+        const std::string table(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "\n"
+            "\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+
+    // with whitespaces
+
+    {
+        const std::string table(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "  \n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "  \n"
+            "  \n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "\n"
+            "  \n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "  \n"
+            "\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+
+    // with whitespaces but no newline
+    {
+        const std::string table(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\"\n"
+            "  "
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+
+
+    // CRLF
+
+    {
+        const std::string table(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "\r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "\r\n"
+            "\r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.toml");
+
+        BOOST_CHECK_EQUAL(toml::get <std::string>(data.at("key")), "value");
+        BOOST_CHECK_EQUAL(toml::find<std::string>(data.at("table"), "key"), "value");
+    }
+
+    // with whitespaces
+
+    {
+        const std::string table(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "  \r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "\r\n"
+            "  \r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "  \r\n"
+            "\r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "  \r\n"
+            "  \r\n"
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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(
+            "key = \"value\"\r\n"
+            "[table]\r\n"
+            "key = \"value\"\r\n"
+            "  "
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_with_newline.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_result.cpp
+++ b/tests/test_result.cpp
@@ -409,3 +409,33 @@ BOOST_AUTO_TEST_CASE(test_or_else)
        BOOST_CHECK_EQUAL(mapped.unwrap_err(), "hogehoge");
    }
 }
+
+BOOST_AUTO_TEST_CASE(test_and_or_other)
+{
+    {
+        const toml::result<int, std::string> r1(toml::ok(42));
+        const toml::result<int, std::string> r2(toml::err<std::string>("foo"));
+
+        BOOST_CHECK_EQUAL(r1,    r1.or_other(r2));
+        BOOST_CHECK_EQUAL(r2,    r1.and_other(r2));
+        BOOST_CHECK_EQUAL(42,    r1.or_other(r2).unwrap());
+        BOOST_CHECK_EQUAL("foo", r1.and_other(r2).unwrap_err());
+    }
+    {
+        auto r1_gen = []() -> toml::result<int, std::string> {
+            return toml::ok(42);
+        };
+        auto r2_gen = []() -> toml::result<int, std::string> {
+            return toml::err<std::string>("foo");
+        };
+        const auto r3 = r1_gen();
+        const auto r4 = r2_gen();
+
+        BOOST_CHECK_EQUAL(r3, r1_gen().or_other (r2_gen()));
+        BOOST_CHECK_EQUAL(r4, r1_gen().and_other(r2_gen()));
+        BOOST_CHECK_EQUAL(42,    r1_gen().or_other (r2_gen()).unwrap());
+        BOOST_CHECK_EQUAL("foo", r1_gen().and_other(r2_gen()).unwrap_err());
+    }
+}
+
+
--- 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/get.hpp
+++ b/toml/get.hpp
@@ -210,8 +210,9 @@ T get(const value& v)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
            "[erorr] toml::get specified container size is ", container.size(),
-            " but there are ", ar.size(), " elements in toml array."),
-            detail::get_region(v), "here"));
+            " but there are ", ar.size(), " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
    }
    std::transform(ar.cbegin(), ar.cend(), container.begin(),
                   [](const value& x){return ::toml::get<value_type>(x);});
@@ -233,7 +234,9 @@ T get(const value& v)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
            "[erorr] toml::get specified std::pair but there are ", ar.size(),
-            " elements in toml array."), detail::get_region(v), "here"));
+            " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
    }
    return std::make_pair(::toml::get<first_type >(ar.at(0)),
                          ::toml::get<second_type>(ar.at(1)));
@@ -264,7 +267,9 @@ T get(const value& v)
        throw std::out_of_range(detail::format_underline(concat_to_string(
            "[erorr] toml::get specified std::tuple with ",
            std::tuple_size<T>::value, "elements, but there are ", ar.size(),
-            " elements in toml array."), detail::get_region(v), "here"));
+            " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
    }
    return detail::get_tuple_impl<T>(ar,
            detail::make_index_sequence<std::tuple_size<T>::value>{});
@@ -295,7 +300,7 @@ T get(const toml::value& v)
 // ============================================================================
 // find and get

-template<typename T>
+template<typename T = ::toml::value>
 decltype(::toml::get<T>(std::declval<const ::toml::value&>()))
 find(const toml::table& tab, const toml::key& ky,
     std::string tablename = "unknown table")
@@ -307,7 +312,7 @@ find(const toml::table& tab, const toml::key& ky,
    }
    return ::toml::get<T>(tab.at(ky));
 }
-template<typename T>
+template<typename T = ::toml::value>
 decltype(::toml::get<T>(std::declval<::toml::value&>()))
 find(toml::table& tab, const toml::key& ky,
     std::string tablename = "unknown table")
@@ -319,7 +324,7 @@ find(toml::table& tab, const toml::key& ky,
    }
    return ::toml::get<T>(tab[ky]);
 }
-template<typename T>
+template<typename T = ::toml::value>
 decltype(::toml::get<T>(std::declval<::toml::value&&>()))
 find(toml::table&& tab, const toml::key& ky,
     std::string tablename = "unknown table")
@@ -332,7 +337,7 @@ find(toml::table&& tab, const toml::key& ky,
    return ::toml::get<T>(std::move(tab[ky]));
 }

-template<typename T>
+template<typename T = ::toml::value>
 decltype(::toml::get<T>(std::declval<const ::toml::value&>()))
 find(const toml::value& v, const toml::key& ky)
 {
@@ -340,12 +345,13 @@ find(const toml::value& v, const toml::key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), detail::get_region(v),
-            "in this table"));
+            "[error] key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return ::toml::get<T>(tab.at(ky));
 }
-template<typename T>
+template<typename T = ::toml::value>
 decltype(::toml::get<T>(std::declval<::toml::value&>()))
 find(toml::value& v, const toml::key& ky)
 {
@@ -353,12 +359,13 @@ find(toml::value& v, const toml::key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), detail::get_region(v),
-            "in this table"));
+            "[error] key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return ::toml::get<T>(tab.at(ky));
 }
-template<typename T>
+template<typename T = ::toml::value>
 decltype(::toml::get<T>(std::declval<::toml::value&&>()))
 find(toml::value&& v, const toml::key& ky)
 {
@@ -366,8 +373,9 @@ find(toml::value&& v, const toml::key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), detail::get_region(v),
-            "in this table"));
+            "[error] key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return ::toml::get<T>(std::move(tab[ky]));
 }
--- 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
--- 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
 {
@@ -200,91 +239,67 @@ struct region final : public region_base

 // to show a better error message.
 inline std::string format_underline(const std::string& message,
-        const region_base& reg, const std::string& comment_for_underline,
+        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
-    const auto line        = reg.line();
-    const auto line_number = reg.line_num();

-    std::string retval;
-    retval += message;
-    retval += newline;
-    retval += " --> ";
-    retval += reg.name();
-    retval += newline;
-    retval += ' ';
-    retval += line_number;
-    retval += " | ";
-    retval += line;
-    retval += newline;
-    retval += make_string(line_number.size() + 1, ' ');
-    retval += " | ";
-    retval += make_string(reg.before(), ' ');
-    retval += make_string(reg.size(),   '~');
-    retval += ' ';
-    retval += comment_for_underline;
-    if(helps.size() != 0)
-    {
-        retval += newline;
-        retval += make_string(line_number.size() + 1, ' ');
-        retval += " | ";
-        for(const auto help : helps)
+    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)
        {
-            retval += newline;
-            retval += "Hint: ";
-            retval += help;
+            return lhs.first->line_num().size() < rhs.first->line_num().size();
        }
-    }
-    return retval;
-}
-
-// to show a better error message.
-inline std::string format_underline(const std::string& message,
-        const region_base& reg1, const std::string& comment_for_underline1,
-        const region_base& reg2, const std::string& comment_for_underline2,
-        std::vector<std::string> helps = {})
-{
-#ifdef _WIN32
-    const auto newline = "\r\n";
-#else
-    const char newline = '\n';
-#endif
-    const auto line1        = reg1.line();
-    const auto line_number1 = reg1.line_num();
-    const auto line2        = reg2.line();
-    const auto line_number2 = reg2.line_num();
-    const auto line_num_width =
-        std::max(line_number1.size(), line_number2.size());
+    )->first->line_num().size();

    std::ostringstream retval;
-    retval << message;
-    retval << newline;
-    retval << " --> ";
-    retval << reg1.name() << newline;;
-//  ---------------------------------------
-    retval << ' ' << std::setw(line_num_width) << line_number1;
-    retval << " | " << line1 << newline;
-    retval << make_string(line_num_width + 1, ' ');
-    retval << " | ";
-    retval << make_string(reg1.before(), ' ');
-    retval << make_string(reg1.size(),   '~');
-    retval << ' ';
-    retval << comment_for_underline1 << newline;
-//  ---------------------------------------
-    retval << " ..." << newline;
-    retval << ' ' << std::setw(line_num_width) << line_number2;
-    retval << " | " << line2 << newline;
-    retval << make_string(line_num_width + 1, ' ');
-    retval << " | ";
-    retval << make_string(reg2.before(), ' ');
-    retval << make_string(reg2.size(),   '~');
-    retval << ' ';
-    retval << comment_for_underline2;
+    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 << " ..." << newline;
+        }
+        else
+        {
+            if(i != 0) {retval << newline;}
+            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;
+    }
+
    if(helps.size() != 0)
    {
        retval << newline;
@@ -300,62 +315,6 @@ 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 = {})
-{
-#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'));
-
-    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 += " | ";
-        for(const auto help : helps)
-        {
-            retval += newline;
-            retval += "Hint: ";
-            retval += help;
-        }
-    }
-    return retval;
-}
-
 } // 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
 {
@@ -396,23 +384,20 @@ struct result
        return std::move(this->succ.value);
    }

-    template<typename U>
-    value_type&       unwrap_or(U& opt) &
+    value_type&       unwrap_or(value_type& opt) &
    {
        if(is_err()) {return opt;}
        return this->succ.value;
    }
-    template<typename U>
-    value_type const& unwrap_or(U const& opt) const&
+    value_type const& unwrap_or(value_type const& opt) const&
    {
        if(is_err()) {return opt;}
        return this->succ.value;
    }
-    template<typename U>
-    value_type&&      unwrap_or(U&& opt) &&
+    value_type        unwrap_or(value_type opt) &&
    {
-        if(is_err()) {return std::move(opt);}
-        return std::move(this->succ.value);
+        if(is_err()) {return opt;}
+        return this->succ.value;
    }

    error_type&       unwrap_err() &
@@ -444,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())));}
@@ -469,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())));}
@@ -494,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);}
@@ -519,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);}
@@ -545,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()));}
@@ -571,27 +556,47 @@ 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()));}
        return ok(std::move(this->as_ok()));
    }

+    // if *this is error, returns *this. otherwise, returns other.
+    result and_other(const result& other) const&
+    {
+        return this->is_err() ? *this : other;
+    }
+    result and_other(result&& other) &&
+    {
+        return this->is_err() ? std::move(*this) : std::move(other);
+    }
+
+    // if *this is okay, returns *this. otherwise, returns other.
+    result or_other(const result& other) const&
+    {
+        return this->is_ok() ? *this : other;
+    }
+    result or_other(result&& other) &&
+    {
+        return this->is_ok() ? std::move(*this) : std::move(other);
+    }
+
    void swap(result<T, E>& other)
    {
        result<T, E> tmp(std::move(*this));
@@ -638,5 +643,22 @@ void swap(result<T, E>& lhs, result<T, E>& rhs)
    return;
 }

+// this might be confusing because it eagerly evaluated, while in the other
+// cases operator && and || are short-circuited.
+//
+// template<typename T, typename E>
+// inline result<T, E>
+// operator&&(const result<T, E>& lhs, const result<T, E>& rhs) noexcept
+// {
+//     return lhs.is_ok() ? rhs : lhs;
+// }
+//
+// template<typename T, typename E>
+// inline result<T, E>
+// operator||(const result<T, E>& lhs, const result<T, E>& rhs) noexcept
+// {
+//     return lhs.is_ok() ? lhs : rhs;
+// }
+
 } // toml11
 #endif// TOML11_RESULT_H
--- 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>
+#include <cstdio>
+
+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
+    {
+        const auto fmt = "%.*g";
+        const auto bsz = std::snprintf(nullptr, 0, fmt, this->float_prec_, f);
+        std::vector<char> buf(bsz + 1, '\0'); // +1 for null character(\0)
+        std::snprintf(buf.data(), buf.size(), fmt, this->float_prec_, f);
+
+        std::string token(buf.begin(), buf.end());
+        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/to_toml.hpp
+++ b/toml/to_toml.hpp
@@ -8,32 +8,38 @@ namespace toml
 {

 template<typename T>
+TOML11_MARK_AS_DEPRECATED
 inline value to_toml(T&& x)
 {
    return value(std::forward<T>(x));
 }

 template<typename T>
+TOML11_MARK_AS_DEPRECATED
 inline value to_toml(T&& x, string_t kind)
 {
    return value(std::forward<T>(x), kind);
 }

+TOML11_MARK_AS_DEPRECATED
 inline value to_toml(local_date d, local_time t)
 {
    return value(local_datetime(d, t));
 }
+TOML11_MARK_AS_DEPRECATED
 inline value to_toml(local_date d, local_time t, time_offset ofs)
 {
    return value(offset_datetime(d, t, ofs));
 }

 template<typename ... Ts>
+TOML11_MARK_AS_DEPRECATED
 inline value to_toml(Ts&& ... xs)
 {
    return value(toml::array{toml::value(std::forward<Ts>(xs)) ... });
 }

+TOML11_MARK_AS_DEPRECATED
 inline value to_toml(std::initializer_list<std::pair<std::string, toml::value>> xs)
 {
    return value(toml::table(xs.begin(), xs.end()));
--- 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
@@ -7,6 +7,16 @@
 #include <memory>
 #include <sstream>

+#if __cplusplus >= 201402L
+#  define TOML11_MARK_AS_DEPRECATED [[deprecated]]
+#elif defined(__GNUC__)
+#  define TOML11_MARK_AS_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#  define TOML11_MARK_AS_DEPRECATED __declspec(deprecated)
+#else
+#  define TOML11_MARK_AS_DEPRECATED
+#endif
+
 namespace toml
 {

@@ -29,8 +39,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 +49,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 +85,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>
 {
@@ -695,9 +681,11 @@ typename detail::toml_default_type<T>::type& value::cast() &
 {
    if(T != this->type_)
    {
-        throw type_error(format_underline(concat_to_string(
-            "[error] toml::value bad_cast to ", T), *region_info_,
-            concat_to_string("the actual type is ", this->type_)));
+        throw type_error(detail::format_underline(concat_to_string(
+            "[error] toml::value bad_cast to ", T), {
+                {this->region_info_.get(),
+                 concat_to_string("the actual type is ", this->type_)}
+            }));
    }
    return switch_cast<T>::invoke(*this);
 }
@@ -706,9 +694,11 @@ typename detail::toml_default_type<T>::type const& value::cast() const&
 {
    if(T != this->type_)
    {
-        throw type_error(format_underline(concat_to_string(
-            "[error] toml::value bad_cast to ", T), *region_info_,
-            concat_to_string("the actual type is ", this->type_)));
+        throw type_error(detail::format_underline(concat_to_string(
+            "[error] toml::value bad_cast to ", T), {
+                {this->region_info_.get(),
+                 concat_to_string("the actual type is ", this->type_)}
+            }));
    }
    return switch_cast<T>::invoke(*this);
 }
@@ -717,9 +707,11 @@ typename detail::toml_default_type<T>::type&&      value::cast() &&
 {
    if(T != this->type_)
    {
-        throw type_error(format_underline(concat_to_string(
-            "[error] toml::value bad_cast to ", T), *region_info_,
-            concat_to_string("the actual type is ", this->type_)));
+        throw type_error(detail::format_underline(concat_to_string(
+            "[error] toml::value bad_cast to ", T), {
+                {this->region_info_.get(),
+                 concat_to_string("the actual type is ", this->type_)}
+             }));
    }
    return switch_cast<T>::invoke(std::move(*this));
 }
@@ -767,6 +759,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:
@@ -800,18 +794,110 @@ inline bool operator>=(const toml::value& lhs, const toml::value& rhs)
    return !(lhs < rhs);
 }

-inline std::string format_error(const std::string& err_msg,
-        const toml::value& v, const std::string& comment)
+namespace detail
 {
-    return detail::format_underline(err_msg, detail::get_region(v), comment);
+inline std::string format_error_impl(const std::string& err_msg,
+        std::vector<std::pair<region_base const*, std::string>> val,
+        std::vector<std::string> hints)
+{
+    return format_underline(err_msg, std::move(val), std::move(hints));
+}
+inline std::string format_error_impl(const std::string& err_msg,
+        std::vector<std::pair<region_base const*, std::string>> val)
+{
+    return format_underline(err_msg, std::move(val));
 }

-inline std::string format_error(const std::string& err_msg,
-        const toml::value& v1, const std::string& comment1,
-        const toml::value& v2, const std::string& comment2)
+template<typename ... Ts>
+std::string format_error_impl(const std::string& err_msg,
+        std::vector<std::pair<region_base const*, std::string>> val,
+        const toml::value& v, const std::string& comment,
+        Ts&& ... args)
 {
-    return detail::format_underline(err_msg, detail::get_region(v1), comment1,
-                                             detail::get_region(v2), comment2);
+    val.push_back(std::make_pair(std::addressof(get_region(v)), comment));
+    return format_error_impl(err_msg, std::move(val), std::forward<Ts>(args)...);
+}
+} // detail
+
+template<typename ... Ts>
+std::string format_error(const std::string& err_msg, Ts&& ... args)
+{
+    std::vector<std::pair<detail::region_base const*, std::string>> val;
+    val.reserve(sizeof...(args) / 2);
+    return detail::format_error_impl(err_msg, std::move(val),
+                                     std::forward<Ts>(args)...);
+}
+
+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
Author	SHA1	Message	Date
Toru Niina	9eb4008d6d	Merge pull request #37 from ToruNiina/to-toml-deprecated feat: mark to_toml as deprecated	2019-03-15 17:12:45 +09:00
ToruNiina	a04544637b	feat: mark to_toml as deprecated because the constructor of `toml::value()` supports all the stuff that are supported by `to_toml`.	2019-03-15 14:29:32 +09:00
Toru Niina	4c7dc17b78	Merge pull request #36 from ToruNiina/refactor-format-underline refactor: remove redundant function overload	2019-03-15 13:41:16 +09:00
ToruNiina	59aaaab436	test: add test to check format_error compiles	2019-03-15 12:40:01 +09:00
ToruNiina	61dfa4a2dc	feat: format any number of values into an err msg ```cpp toml::format_error("[error] message", v1, "v1", v2, "v2", ...); ```	2019-03-15 12:38:37 +09:00
ToruNiina	ca337a1110	chore: merge branch 'master' into travis-ci	2019-03-14 23:02:04 +09:00
ToruNiina	510e10de95	ci: test numerous compilers on CI	2019-03-14 22:58:44 +09:00
ToruNiina	0babe8d589	fix: use format_underline for N regions everywhere	2019-03-14 00:59:10 +09:00
ToruNiina	5b2ce26721	refactor: remove redundant function since N region format_underline() has been implemented, overloads for 1 and 2 region(s) are not needed.	2019-03-14 00:56:35 +09:00
Toru Niina	db4d99cd4f	Merge pull request #35 from ToruNiina/suppress-warning fix: suppress warning about sign-unsign comparison	2019-03-13 15:01:51 +09:00
ToruNiina	74ceceef73	fix: suppress warning about sign-unsign comparison The solution is not ideal, but it's okay at the line	2019-03-13 14:03:04 +09:00
Toru Niina	360e890cc0	Merge pull request #34 from ToruNiina/consider-locale fix: use snprintf instead of stringstream	2019-03-13 09:56:32 +09:00
ToruNiina	46b35870c5	style: remove needless type casting	2019-03-13 01:17:27 +09:00
ToruNiina	dddcecb034	fix: use snprintf instead of stringstream to avoid the effect of locale	2019-03-12 23:37:46 +09:00
ToruNiina	084e82a8a9	chore: update README	2019-03-07 14:09:02 +09:00
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
Toru Niina	5dfdbe4bff	Merge pull request #20 from ToruNiina/format-error add an extra parameter `hints` to format_error	2018-12-27 20:34:53 +09:00
Toru Niina	4584eeb57a	Merge pull request #19 from ToruNiina/find-default-type add default template arg to toml::find	2018-12-27 20:34:36 +09:00
ToruNiina	aa67069387	move hints to the internal function	2018-12-27 16:32:20 +09:00
ToruNiina	ee3424ad51	add an extra parameter `hints` to format_error	2018-12-27 16:26:23 +09:00
ToruNiina	17def14ab6	add default template arg to toml::find in most of the use cases, toml::value is used (to show error message).	2018-12-27 15:58:50 +09: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
Toru Niina	b5b8830c29	Merge pull request #17 from ToruNiina/hotfix fix the error with BOM and end of file w/o newline	2018-12-24 16:37:10 +09:00
ToruNiina	87a5c844c2	add test cases for the end-of-file problems	2018-12-24 16:02:32 +09:00
ToruNiina	11c7ee4501	fix the case of file w/o newline at the end toml::parse failed with the file that contains whitespace or comment at the end of file without newline. this commit fixes the error.	2018-12-24 16:00:33 +09:00
ToruNiina	d24a188d4c	fix the error while reading BOM. remove possible UB because of the use-after-move.	2018-12-24 15:06:26 +09:00
Toru Niina	29876221f8	Merge pull request #15 from ToruNiina/performance speedup by removing needless format_underline	2018-12-23 18:30:19 +09:00
ToruNiina	7c03c446fe	speedup by removing needless format_underline drastical speedup for long toml files	2018-12-23 15:22:12 +09:00
Toru Niina	cfdd4d4a90	Merge pull request #14 from ToruNiina/error-message improve error message quality	2018-12-22 18:46:00 +09:00
ToruNiina	5546b3389d	Merge branch 'master' into error-message	2018-12-22 17:55:59 +09:00
ToruNiina	9c95992dad	fix error message for empty value	2018-12-22 17:44:09 +09:00
ToruNiina	edb48b2872	add test_error_detection to check it detects error	2018-12-22 17:43:42 +09:00
ToruNiina	c63ac7e435	detect syntax_error; appending array-of-tables toml file like the following is explicitly prohibited. a = [{b = 1}] [[a]] b = 2 this commit detects this kind of syntax-error while parsing toml file	2018-12-22 17:07:06 +09:00
ToruNiina	fec49aaaa3	fix error message: add missing spaces	2018-12-22 17:06:36 +09:00
ToruNiina	617187969c	fix result::unwrap_or with rvalue ref; merge branch 'hotfix'	2018-12-17 23:54:17 +09:00
ToruNiina	e3217cd572	quit returning rvalue ref from unwrap_or	2018-12-17 23:17:45 +09:00
ToruNiina	4d02f399a2	add temporary to receive rvalue	2018-12-17 23:03:53 +09:00
ToruNiina	24723226f1	remove template argument from result::unwrap_or	2018-12-17 19:18:16 +09:00
ToruNiina	7b3684b54e	add and_other and or_other to toml::result effectively same as Rust's std::Result::and and or.	2018-12-17 18:24:41 +09:00
ToruNiina	13c1f9c259	output filename of the second value2 if different in format_error.	2018-12-17 18:07:57 +09:00
ToruNiina	6df75ad28e	fix README	2018-12-17 16:56:09 +09:00