chore: fix example of err msg by re-running sample

fix: restore the back compat of format_error
the following code was okay in the last release ``` toml::format_error("[test]", v, "test", {"hint1", "hint2"}) ``` but was not okay in the current master. This commit fixes this. cons: By this, the number of values to show is limited upto 3.
2025-12-16 03:08:52 +08:00 · 2019-03-21 18:12:35 +09:00 · 2019-03-20 20:46:22 +09:00 · 2019-03-20 19:30:08 +09:00 · 2019-03-20 19:29:03 +09:00 · 2019-03-20 12:06:55 +09:00
31 changed files with 1832 additions and 525 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -0,0 +1,59 @@
+version: 2.1
+
+jobs:
+  test_suite:
+    environment:
+      - GOPATH: /home/circleci/go
+    docker:
+      - image: circleci/golang:1.9
+    steps:
+      - checkout
+      - run:
+          command: |
+              g++ --version
+              cd tests/
+              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check_toml_test.cpp -o check_toml_test
+              go get github.com/BurntSushi/toml-test
+              $GOPATH/bin/toml-test ./check_toml_test
+  output_result:
+    docker:
+      - image: circleci/buildpack-deps:bionic
+    steps:
+      - checkout
+      - run:
+          command: |
+              g++ --version
+              cd tests/
+              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check.cpp -o check
+              git clone https://github.com/BurntSushi/toml-test.git
+              cp check toml-test/tests/invalid
+              cp check toml-test/tests/valid
+              cd toml-test/tests/invalid
+              for f in $(ls ./*.toml);
+                do echo "==> ${f}";
+                cat ${f};
+                echo "---------------------------------------";
+                ./check ${f} invalid;
+                if [ $? -ne 0 ] ; then
+                  exit 1
+                fi
+                echo "=======================================";
+              done
+              cd ../valid
+              for f in $(ls ./*.toml);
+                do echo "==> ${f}";
+                cat ${f};
+                echo "---------------------------------------";
+                ./check ${f} valid;
+                if [ $? -ne 0 ] ; then
+                  exit 1
+                fi
+                echo "=======================================";
+              done
+
+workflows:
+  version: 2.1
+  test:
+    jobs:
+      - test_suite
+      - output_result
--- a/README.md
+++ b/README.md
@@ -1,25 +1,53 @@
 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/branch/master?svg=true)](https://ci.appveyor.com/project/ToruNiina/toml11/branch/master)
+[![Build Status on TravisCI](https://travis-ci.org/ToruNiina/toml11.svg?branch=master)](https://travis-ci.org/ToruNiina/toml11)
+[![Build status on Appveyor](https://ci.appveyor.com/api/projects/status/m2n08a926asvg5mg/branch/master?svg=true)](https://ci.appveyor.com/project/ToruNiina/toml11/branch/master)
+[![Build status on CircleCI](https://circleci.com/gh/ToruNiina/toml11/tree/master.svg?style=svg)](https://circleci.com/gh/ToruNiina/toml11/tree/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/encoder depending only on C++ standard library.
+toml11 is a 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.

-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.
+It passes [the language agnostic test suite for TOML parsers by BurntSushi](https://github.com/BurntSushi/toml-test).
+Not only the test suite itself, a TOML reader/encoder also runs on [CircleCI](https://circleci.com/gh/ToruNiina/toml11).
+You can see the error messages about invalid files and serialization results of valid files at
+[CircleCI](https://circleci.com/gh/ToruNiina/toml11).

-## How to use
+## Table of Contents

-## Installation
+- [Integration](#integration)
+- [Decoding a toml file](#decoding-a-toml-file)
+  - [In the case of syntax error](#in-the-case-of-syntax-error)
+- [Getting a toml value](#getting-a-toml-value)
+  - [In the case of type error](#in-the-case-of-type-error)
+- [Getting an array](#getting-an-array)
+- [Getting a table](#getting-a-table)
+  - [Dotted keys](#dotted-keys)
+- [Getting an array of tables](#getting-an-array-of-tables)
+- [Cost of conversion](#cost-of-conversion)
+- [Getting datetime and its variants](#getting-datetime-and-its-variants)
+- [Getting with a fallback](#getting-with-a-fallback)
+- [Expecting conversion](#expecting-conversion)
+- [Finding a value from a table](#finding-a-value-from-a-table)
+- [Checking value type](#checking-value-type)
+- [Visiting a toml::value](#visiting-a-tomlvalue)
+- [TOML literal](#toml-literal)
+- [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types)
+- [Invalid UTF-8 Codepoints](#invalid-utf-8-codepoints)
+- [Formatting user-defined error messages](#formatting-user-defined-error-messages)
+- [Serializing TOML data](#serializing-toml-data)
+- [Underlying types](#underlying-types)
+- [Running Tests](#running-tests)
+- [Contributors](#contributors)
+- [Licensing Terms](#licensing-terms)
+
+## Integration

 Just include the file after adding it to the include path.

@@ -34,41 +62,40 @@ int main()
 }
 ```

-### Decoding toml file
+## Decoding a toml file

-The only thing you have to do is to pass a filename to the `toml::parse` function.
+To parse a toml file, the only thing you have to do is
+to pass a filename to the `toml::parse` function.

 ```cpp
 const std::string fname("sample.toml");
 const toml::table data = toml::parse(fname);
 ```

-In the case of file open error, it will throw `std::runtime_error`.
+If it encounters a 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.
+You can also pass a `std::istream` to the  `toml::parse` function.
+To show a filename in an error message, it is recommended to pass the filename
+with the stream.

 ```cpp
 std::ifstream ifs("sample.toml", std::ios_base::binary);
 assert(ifs.good());
-const auto data = toml::parse(ifs /*, "filename" (optional)*/);
+const auto data = toml::parse(ifs, /*optional*/ "sample.toml");
 ```

-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).
+Note that on Windows, if a file is opened in text-mode, CRLF ("\r\n") will
+automatically be converted to LF ("\n") and this causes inconsistency between
+file size and the contents that would be read. This causes weird error.
+To use a file stream with `toml::parse` on Windows, don't forget to open it
+in binary mode.

 ### 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 has clean and informative error messages inspired by Rust and
+it looks like the following.

 ```console
 terminate called after throwing an instance of 'toml::syntax_error'
@@ -78,8 +105,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, it is helpful to see
+where they are. toml11 shows both at the same time like the following.

 ```console
 terminate called after throwing an instance of 'toml::syntax_error'
@@ -93,15 +120,16 @@ terminate called after throwing an instance of 'toml::syntax_error'
 ```

 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!
+status is not ideal. If you encounter a weird error message, please let us know
+and contribute to improve the quality!

-### Getting a toml value
+## Getting a toml value

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

 ```toml
+# sample.toml
 answer  = 42
 pi      = 3.14
 numbers = [1,2,3]
@@ -111,6 +139,7 @@ key = "value"
 ```

 ``` cpp
+const auto data      = toml::parse("sample.toml");
 const auto answer    = toml::get<std::int64_t    >(data.at("answer"));
 const auto pi        = toml::get<double          >(data.at("pi"));
 const auto numbers   = toml::get<std::vector<int>>(data.at("numbers"));
@@ -120,20 +149,24 @@ 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.
+`toml::get` returns a reference through which you can modify the content.

 ```cpp
-toml::get<toml::integer>(data["answer"]) = 6 * 9;
+auto  data   = toml::parse("sample.toml");
+auto& answer = toml::get<toml::integer>(data["answer"]);     // get reference
+answer = 6 * 9;                                              // write to data.answer
 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).

-#### Passing invalid type to toml::get
+NOTE: To enable to get a reference, conversions between Float and Integer are not supported.

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

 ```console
@@ -144,15 +177,21 @@ 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
+pointers to represent its range in a file. The entire contents of a file is
+shared by `toml::value`s and remains on the heap memory. It is recommended to
+destruct all the `toml::value` classes after configuring your application
+if you have a large TOML file compared to the memory resource.

-### Getting arrays
+## Getting an array

-You can set any kind of `container` class to obtain a `toml::array` except for `map`-like classes.
+You can get any kind of `container` class from a `toml::array`
+except for `map`-like classes.

 ``` cpp
+// # sample.toml
+// numbers = [1,2,3]
+
 const auto vc  = toml::get<std::vector<int>  >(data.at("numbers"));
 const auto ls  = toml::get<std::list<int>    >(data.at("numbers"));
 const auto dq  = toml::get<std::deque<int>   >(data.at("numbers"));
@@ -161,16 +200,16 @@ const auto ar  = toml::get<std::array<int, 3>>(data.at("numbers"));
 // it will throw toml::type_error because std::array is not resizable.
 ```

-Surprisingly, you can also get a `toml::array` as `std::pair` and `std::tuple.`
+Surprisingly, you can also get `std::pair`s and `std::tuple`s from `toml::array`.

 ```cpp
 const auto tp = toml::get<std::tuple<short, int, unsigned int>>(data.at("numbers"));
 ```

-The case when you need this functionality is to get an array of arrays.
+This functionality is helpful when you have the following toml file.

 ```toml
-aofa = [[1,2,3], ["foo", "bar", "baz"]] # toml allows this
+array_of_arrays = [[1, 2, 3], ["foo", "bar", "baz"]] # toml allows this
 ```

 What is the corresponding C++ type? Obviously, it is a `std::pair` of `std::vector`s.
@@ -178,21 +217,21 @@ What is the corresponding C++ type? Obviously, it is a `std::pair` of `std::vect
 ```cpp
 const auto aofa = toml::get<
    std::pair<std::vector<int>, std::vector<std::string>>
-    >(data.at("aofa"));
+    >(data.at("array_of_arrays"));
 ```

-If you don't know what the type is inside the array, you can use `toml::array`,
+If you don't know the type of the elements, 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));
+const auto aofa  = toml::get<toml::array>(data.at("array_of_arrays"));
+const auto first = toml::get<std::vector<int>>(aofa.at(0));
 ```

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

-### Getting tables
+## Getting a table

 `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`.
@@ -219,12 +258,13 @@ key2 = "bar" # toml String
 ```

 ```cpp
+const auto data = toml::parse("sample.toml");
 const auto tab = toml::get<std::map<std::string, std::string>>(data.at("tab"));
 std::cout << tab["key1"] << std::endl; // foo
 std::cout << tab["key2"] << std::endl; // bar
 ```

-### Dotted keys
+## Dotted keys

 TOML v0.5.0 has a new feature named "dotted keys".
 You can chain keys to represent the structure of the data.
@@ -249,41 +289,49 @@ const auto physical = toml::get<toml::table>(data.at("physical"));
 const auto color    = toml::get<std::string>(physical.at("color"));
 ```

-### An array of tables
+## Getting 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.

 ```toml
-array_of_inline_table = [{key = "value1"}, {key = "value2"}, {key = "value3"}]
+# sample.toml
+array_of_inline_tables = [{key = "value1"}, {key = "value2"}, {key = "value3"}]

-[[array_of_table]]
+[[array_of_tables]]
 key = "value4"
-[[array_of_table]]
+[[array_of_tables]]
 key = "value5"
-[[array_of_table]]
+[[array_of_tables]]
 key = "value6"
 ```

 ```cpp
-const auto aot1 = toml::get<std::vector<toml::table>>(data.at("array_of_inline_table"));
-const auto aot2 = toml::get<std::vector<toml::table>>(data.at("array_of_table"));
+const auto data = toml::parse("sample.toml");
+const auto aot1 = toml::get<std::vector<toml::table>>(data.at("array_of_inline_tables"));
+const auto aot2 = toml::get<std::vector<toml::table>>(data.at("array_of_tables"));
 ```

-### Cost of conversion
+## 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.
+Of course in some cases this overhead is not ignorable.

-By passing the exact types, `toml::get` returns reference that has nealy zero overhead.
+```cpp
+// the following code constructs a std::vector.
+// it requires heap allocation for vector and element conversion.
+const auto array = toml::get<std::vector<int>>(data.at("foo"));
+```
+
+By passing the exact types, `toml::get` returns reference that has no overhead.

 ``` cpp
 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
+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
@@ -292,34 +340,61 @@ const auto& num1 = toml::get<toml::integer>(numbers.at(1));
 const auto& num2 = toml::get<toml::integer>(numbers.at(2));
 ```

-### Datetime and its variants
+## Getting 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`.
+`local_datetime`, and `offset_datetime`.
+
+Since `local_date`, `local_datetime`, and `offset_datetime` represent a time
+point, you can convert them to `std::chrono::system_clock::time_point`.
+
+Contrary, `local_time` does not represents a time point because they lack a
+date information, but it can be converted to `std::chrono::duration` that
+represents a duration from the beginning of the day, `00:00:00.000`.

 ```toml
-time = 12:30:00
 date = 2018-12-23
+time = 12:30:00
+l_dt = 2018-12-23T12:30:00
+o_dt = 2018-12-23T12:30:00+09:30
 ```

 ```cpp
-const auto dur = toml::get<std::chrono::minutes>(data.at("time")); // 12 * 60 + 30 min
-const auto tp  = toml::get<std::chrono::system_clock::time_point>(data.at("date"));
+const auto data = toml::parse("sample.toml");
+
+const auto date = toml::get<std::chrono::system_clock::time_point>(data.at("date"));
+const auto l_dt = toml::get<std::chrono::system_clock::time_point>(data.at("l_dt"));
+const auto o_dt = toml::get<std::chrono::system_clock::time_point>(data.at("o_dt"));
+
+const auto time = toml::get<std::chrono::minutes>(data.at("time")); // 12 * 60 + 30 min
 ```

-### Getting with a fallback
+toml11 contains datetime as its own struct.
+You can see the definitions in [toml/datetime.hpp](toml/datetime.hpp).

- `toml::get_or` returns a default value if `toml::get<T>` failed.
+## Getting with a fallback
+
+`toml::get_or` returns a default value if `toml::get<T>` failed.

 ```cpp
-toml::table data; // empty table!
-const auto value = toml::get_or(data, "key", 42); // value => int 42.
+toml::value v("foo"); // v contains String
+const int value = toml::get_or(v, 42); // conversion fails. it returns 42.
 ```

-`toml::get_or` automatically deduces what type you want to get from the default value you passed.
+`toml::get_or` automatically deduces what type you want to get from
+the default value you passed.

-### Expecting conversion
+To get a reference through this function, take care about the default value.
+
+```cpp
+toml::value v("foo"); // v contains String
+toml::integer& i = toml::get_or(v, 42); // does not work because binding `42`
+                                        // to `integer&` is invalid
+toml::integer opt = 42;
+toml::integer& i = toml::get_or(v, opt); // this works.
+```
+
+## Expecting conversion

 By using `toml::expect`, you will get your expected value or an error message
 without throwing `toml::type_error`.
@@ -343,7 +418,7 @@ const auto value = toml::expect<int>(data.at("number"))
    }).unwrap_or(/*default value =*/ 3.14);
 ```

-### Finding value from table
+## Finding a value from a 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
@@ -354,7 +429,7 @@ const auto data = toml::parse("example.toml");
 const auto num  = toml::find<int>(data, "num", /*for err msg*/"example.toml");
 ```

-If the value does not exist, it throws `std::out_of_range` with informative error message.
+If the value does not exist, it throws `std::out_of_range` with an error message.

 ```console
 terminate called after throwing an instance of 'std::out_of_range'
@@ -373,7 +448,8 @@ const auto num  = toml::find<int>(data.at("table"), "num");
 ```

 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.
+you don't need to pass where you find the value.
+`toml::find` will show you an error message including table location.

 ```console
 terminate called after throwing an instance of 'std::out_of_range'
@@ -385,47 +461,70 @@ terminate called after throwing an instance of 'std::out_of_range'

 If it's not a `toml::table`, the same error as "invalid type" would be thrown.

-### Checking value type
+There is another utility function, `toml::find_or`.
+It is almost same as `toml::find`, but returns a default value if the value is
+not found or has a different type, like `toml::get_or`.

-When you don't know the exact type of toml-value, you can get `enum` type from `toml::value`.
+```cpp
+const auto data = toml::parse("example.toml");
+const auto num  = toml::find_or(data.at("table"), "num", 42);
+```
+
+## Checking value type
+
+You can check what type of value does `toml::value` contains by `is_*` function.
+
+```cpp
+toml::value v = /* ... */;
+if(v.is_integer() && toml::get<int>(v) == 42)
+{
+    std::cout << "value is 42" << std::endl;
+}
+```
+
+The complete list of the functions is below.
+
+```cpp
+const toml::value v(/*...*/);
+v.is_boolean();
+v.is_integer();
+v.is_float();
+v.is_string();
+v.is_offset_datetime();
+v.is_local_datetime();
+v.is_local_date();
+v.is_local_time();
+v.is_array();
+v.is_table();
+v.is_uninitialized();
+```
+
+Also, you can get `enum class` value from `toml::value`.

 ```cpp
 switch(data.at("something").type())
 {
-    case toml::value_t::Integer: /* do some stuff */; break;
-    case toml::value_t::Float  : /* do some stuff */; break;
-    case toml::value_t::String : /* do some stuff */; break;
+    case toml::value_t::Integer: /*do some stuff*/ ; break;
+    case toml::value_t::Float  : /*do some stuff*/ ; break;
+    case toml::value_t::String : /*do some stuff*/ ; break;
    default : throw std::runtime_error(
        "unexpected type : " + toml::stringize(data.at("something").type()));
 }
 ```

-### Fill only the matched value
+The complete list of the `enum`s can be found in the section
+[underlying types](#underlying-types).

-The more sophisticated way is using `toml::from_toml` and `std::tie`.
+The `enum`s can be used as a parameter of `toml::value::is` function like the following.

 ```cpp
-toml::table data{{"something", toml::value("foo")}};
-int         i = 0;
-double      d = 0.;
-std::string s;
-toml::from_toml(std::tie(i, d, s), data.at("something"));
-std::cout << i << ", " << d << ", " << s << std::endl; // 0, 0, foo
+toml::value v = /* ... */;
+if(v.is(toml::value_t::Boolean)) // ...
 ```

-Here, only matched value will be filled. The others are left intact after calling `from_toml`.
-It should be noted that `toml::from_toml` returns as usual even if there are no matched type.
+## Visiting a toml::value

-`from_toml` can be used also for single type. 
-
-```cpp
-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
+toml11 provides `toml::visit` to apply a function to `toml::value` in the
 same way as `std::variant`.

 ```cpp
@@ -439,29 +538,202 @@ 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
+## TOML literal

-toml11 shows warning if a value of an escape sequence used
-to represent unicode character exceeds the unicode range.
+toml11 supports `"..."_toml` literal.
+It accept both a bare value and a file content.

-```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.
- --> example.toml
- 3 | exceeds_unicode = "\U0011FFFF example"
-   |                     ~~~~~~~~~ should be in [0x00..0x10FFFF]
+```cpp
+using namespace toml::literals::toml_literals;
+
+// `_toml` can convert a bare value without key
+const toml::value v = u8"0xDEADBEEF"_toml;
+// v is an Integer value containing 0xDEADBEEF.
+
+// raw string literal (`R"(...)"` is useful for this purpose)
+const toml::value t = u8R"(
+    title = "this is TOML literal"
+    [table]
+    key = "value"
+)"_toml;
+// the literal will be parsed and the result will be contained in t
 ```

-Also, toml11 throws `std::domain_error` if the code point exceeds the range that can be represented by utf-8.
+The literal function is defined in the same way as the standard library literals
+such as `std::literals::string_literals::operator""s`.

-```console
-terminate called after throwing an instance of 'std::range_error'
-  what():  [error] input codepoint (0020FFFF) is too large to encode as utf-8.
- --> example.toml
- 3 | exceeds_utf8    = "\U0020FFFF example"
-   |                     ~~~~~~~~~ should be in [0x00..0x10FFFF]
+```cpp
+namespace toml
+{
+inline namespace literals
+{
+inline namespace toml_literals
+{
+toml::value operator""_toml(const char* str, std::size_t len);
+
+} // toml_literals
+} // literals
+} // toml
 ```

-### Formatting your error
+Access to the operator can be gained with `using namespace toml::literals;`,
+`using namespace toml::toml_literals`, and `using namespace toml::literals::toml_literals`.
+
+## Conversion between toml value and arbitrary types
+
+You can also use `toml::get` and other related functions with the types you defined
+after you implement some stuff.
+
+```cpp
+namespace ext
+{
+struct foo
+{
+    int         a;
+    double      b;
+    std::string c;
+};
+} // ext
+
+const auto data = toml::parse("example.toml");
+
+const foo f = toml::get<ext::foo>(data.at("foo"));
+```
+
+There are 2 ways to use `toml::get` with the types that you defined.
+
+The first one is to implement `from_toml(const toml::value&)` member function.
+
+```cpp
+namespace ext
+{
+struct foo
+{
+    int         a;
+    double      b;
+    std::string c;
+
+    void from_toml(const toml::value& v)
+    {
+        this->a = toml::find<int        >(v, "a");
+        this->b = toml::find<double     >(v, "b");
+        this->c = toml::find<std::string>(v, "c");
+        return;
+    }
+};
+} // ext
+```
+
+In this way, because `toml::get` first constructs `foo` without arguments,
+the type should be default-constructible.
+
+The second is to implement specialization of `toml::from` for your type.
+
+```cpp
+namespace ext
+{
+struct foo
+{
+    int         a;
+    double      b;
+    std::string c;
+};
+} // ext
+
+namespace toml
+{
+template<>
+struct from<ext::foo>
+{
+    ext::foo from_toml(const toml::value& v)
+    {
+        ext::foo f;
+        f.a = toml::find<int        >(v, "a");
+        f.b = toml::find<double     >(v, "b");
+        f.c = toml::find<std::string>(v, "c");
+        return f;
+    }
+};
+} // toml
+```
+
+In this way, since the conversion function is defined outside of the class,
+you can add conversion between `toml::value` and classes defined in another library.
+
+Note that you cannot implement both of the functions because the overload
+resolution of `toml::get` will be ambiguous.
+
+----
+
+The opposite direction is also supported in a similar way. You can directly
+pass your type to `toml::value`'s constructor by introducing `into_toml` or
+`toml::into<T>`.
+
+```cpp
+namespace ext
+{
+struct foo
+{
+    int         a;
+    double      b;
+    std::string c;
+
+    toml::table into_toml() const // you need to mark it const.
+    {
+        return toml::table{{"a", this->a}, {"b", this->b}, {"c", this->c}};
+    }
+};
+} // ext
+
+ext::foo    f{42, 3.14, "foobar"};
+toml::value v(f);
+```
+
+The definition of `toml::into<T>` is similar to `toml::from<T>`.
+
+```cpp
+namespace ext
+{
+struct foo
+{
+    int         a;
+    double      b;
+    std::string c;
+};
+} // ext
+
+namespace toml
+{
+template<>
+struct into<ext::foo>
+{
+    toml::table into_toml(const ext::foo& f)
+    {
+        return toml::table{{"a", f.a}, {"b", f.b}, {"c", f.c}};
+    }
+};
+} // toml
+
+ext::foo    f{42, 3.14, "foobar"};
+toml::value v(f);
+```
+
+Any type that can be converted to `toml::value`, e.g. `toml::table`, `toml::array`,
+is okay to return from `into_toml`.
+
+## Invalid UTF-8 codepoints
+
+toml11 throws `syntax_error` if a value of an escape sequence
+representing unicode character is not a valid UTF-8 codepoint.
+
+```console
+  what():  [error] toml::read_utf8_codepoint: input codepoint is too large.
+ --> utf8.toml
+ 1 | exceeds_unicode = "\U0011FFFF example"
+   |                              ^--------- should be in [0x00..0x10FFFF]
+```
+
+## Formatting user-defined error messages

 When you encounter an error after you read the toml value, you may want to
 show the error with the value.
@@ -514,22 +786,18 @@ you will get an error message like this.
   |       ~~ maximum number here
 ```

-### Serializing TOML data
+## Serializing TOML data

-toml11 v2.1.0 enables you to serialize data into toml format.
+toml11 (after 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.
+toml11 automatically makes a small table and small array inline.
 You can specify the width to make them inline by `std::setw` for streams.

 ```cpp
@@ -572,23 +840,8 @@ 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`).
+`std::setprecision` to stream.

 ```cpp
 const auto data = toml::table{
@@ -601,8 +854,32 @@ std::cout << std::setprecision(17) << data << std::endl;
 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);
+There is another way to format toml values, `toml::format()`.
+It returns `std::string` that represents a value.
+
+```cpp
+const toml::value v{{"a", 42}};
+const std::string fmt = toml::format(v);
+// a = 42
+```
+
+Note that since `toml::format` formats a value, the resulting string may lack
+the key value.
+
+```cpp
+const toml::value v{3.14};
+const std::string fmt = toml::format(v);
+// 3.14
+```
+
+To control the width and precision, `toml::format` receives optional second and
+third arguments to set them. By default, the witdh is 80 and the precision is
+`std::numeric_limits<double>::max_digit10`.
+
+```cpp
+const auto serial = toml::format(data, /*width = */ 0, /*prec = */ 17);
 ```

 ## Underlying types
@@ -618,7 +895,7 @@ The toml types (can be used as `toml::*` in this library) and corresponding `enu
 | LocalDate      | `toml::local_date`                           | `toml::value_t::LocalDate`      |
 | LocalTime      | `toml::local_time`                           | `toml::value_t::LocalTime`      |
 | LocalDatetime  | `toml::local_datetime`                       | `toml::value_t::LocalDatetime`  |
-| OffsetDatetime | `toml::offset_datetime`                      | `toml::value_t::offsetDatetime` |
+| OffsetDatetime | `toml::offset_datetime`                      | `toml::value_t::OffsetDatetime` |
 | Array          | `std::vector<toml::value>`                   | `toml::value_t::Array`          |
 | Table          | `std::unordered_map<toml::key, toml::value>` | `toml::value_t::Table`          |

@@ -633,16 +910,33 @@ 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`.

+## Running Tests
+
+To run test codes, you need to clone toml-lang/toml repository under `build/` directory
+because some of the test codes read a file in the repository.
+
+```sh
+$ mkdir build
+$ cd build
+$ git clone https://github.com/toml-lang/toml.git
+$ cmake ..
+$ make
+$ make test
+```
+
+To run the language agnostic test suite, you need to compile
+`tests/check_toml_test.cpp` and pass it to the tester.
+
 ## Contributors

-I thank the contributor for providing great feature to this repository.
+I appreciate the help of the contributors who introduced the great feature to this library.

 - 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
+  - Improved error messages for invaild keys to show the location where the parser fails

 ## Licensing terms

--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -20,15 +20,16 @@ set(TEST_NAMES
    test_parse_inline_table
    test_parse_key
    test_parse_table_key
+    test_literals
    test_get
    test_get_related_func
-    test_to_toml
    test_from_toml
    test_parse_file
    test_serialize_file
    test_parse_unicode
    test_error_detection
    test_format_error
+    test_extended_conversions
 )

 CHECK_CXX_COMPILER_FLAG("-Wall" COMPILER_SUPPORTS_WALL)
@@ -98,3 +99,8 @@ foreach(TEST_NAME ${TEST_NAMES})
        )
    endif()
 endforeach(TEST_NAME)
+
+# this test is to check it compiles. it will not run
+add_executable(test_multiple_translation_unit
+               test_multiple_translation_unit_1.cpp
+               test_multiple_translation_unit_2.cpp)
--- a/tests/check.cpp
+++ b/tests/check.cpp
@@ -0,0 +1,41 @@
+#include "toml.hpp"
+#include <iostream>
+#include <iomanip>
+
+int main(int argc, char **argv)
+{
+    if(argc != 3)
+    {
+        std::cerr << "usage: ./check [filename] [valid|invalid]" << std::endl;
+        return 1;
+    }
+
+    const std::string file_kind(argv[2]);
+
+    try
+    {
+        const auto data = toml::parse(argv[1]);
+        std::cout << std::setprecision(16) << std::setw(80) << data;
+        if(file_kind == "valid")
+        {
+            return 0;
+        }
+        else
+        {
+            return 1;
+        }
+    }
+    catch(const toml::syntax_error& err)
+    {
+        std::cout << "what(): " << err.what() << std::endl;
+        if(file_kind == "invalid")
+        {
+            return 0;
+        }
+        else
+        {
+            return 1;
+        }
+    }
+    return 127;
+}
--- a/tests/check_toml_test.cpp
+++ b/tests/check_toml_test.cpp
@@ -0,0 +1,142 @@
+#include "toml.hpp"
+#include <iostream>
+#include <iomanip>
+
+struct json_serializer
+{
+    void operator()(toml::boolean v)
+    {
+        std::cout << "{\"type\":\"bool\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(toml::integer v)
+    {
+        std::cout << "{\"type\":\"integer\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(toml::floating v)
+    {
+        std::cout << "{\"type\":\"float\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::string& v)
+    {
+        // since toml11 automatically convert string to multiline string that is
+        // valid only in TOML, we need to format the string to make it valid in
+        // JSON.
+        std::cout << "{\"type\":\"string\",\"value\":\""
+                  << this->escape_string(v.str) << "\"}";
+        return ;
+    }
+    void operator()(const toml::local_time& v)
+    {
+        std::cout << "{\"type\":\"local_time\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::local_date& v)
+    {
+        std::cout << "{\"type\":\"local_date\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::local_datetime& v)
+    {
+        std::cout << "{\"type\":\"local_datetime\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::offset_datetime& v)
+    {
+        std::cout << "{\"type\":\"datetime\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::array& v)
+    {
+        if(!v.empty() && v.front().is_table())
+        {
+            std::cout << '[';
+            bool is_first = true;
+            for(const auto& elem : v)
+            {
+                if(!is_first) {std::cout << ", ";}
+                is_first = false;
+                toml::visit(*this, elem);
+            }
+            std::cout << ']';
+        }
+        else
+        {
+            std::cout << "{\"type\":\"array\",\"value\":[";
+            bool is_first = true;
+            for(const auto& elem : v)
+            {
+                if(!is_first) {std::cout << ", ";}
+                is_first = false;
+                toml::visit(*this, elem);
+            }
+            std::cout << "]}";
+        }
+        return ;
+    }
+    void operator()(const toml::table& v)
+    {
+        std::cout << '{';
+        bool is_first = true;
+        for(const auto& elem : v)
+        {
+            if(!is_first) {std::cout << ", ";}
+            is_first = false;
+            std::cout << toml::format(toml::string(elem.first),
+                                      std::numeric_limits<std::size_t>::max());
+            std::cout << ':';
+            toml::visit(*this, elem.second);
+        }
+        std::cout << '}';
+        return ;
+    }
+
+    std::string escape_string(const std::string& s) const
+    {
+        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;
+    }
+};
+
+int main()
+{
+    try
+    {
+        std::vector<char> buf;
+        std::cin.peek();
+        while(!std::cin.eof())
+        {
+            buf.push_back(std::cin.get());
+            std::cin.peek();
+        }
+        std::string bufstr(buf.begin(), buf.end());
+
+        std::istringstream ss(bufstr);
+
+        const auto data = toml::parse(ss);
+        std::cout << std::setprecision(std::numeric_limits<double>::max_digits10);
+        toml::visit(json_serializer(), data);
+        return 0;
+    }
+    catch(const toml::syntax_error& err)
+    {
+        std::cout << "what(): " << err.what() << std::endl;
+        return 1;
+    }
+}
--- a/tests/test_extended_conversions.cpp
+++ b/tests/test_extended_conversions.cpp
@@ -0,0 +1,116 @@
+#define BOOST_TEST_MODULE "test_extended_conversions"
+#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>
+
+namespace extlib
+{
+struct foo
+{
+    int a;
+    std::string b;
+};
+struct bar
+{
+    int a;
+    std::string b;
+
+    void from_toml(const toml::value& v)
+    {
+        this->a = toml::find<int>(v, "a");
+        this->b = toml::find<std::string>(v, "b");
+        return ;
+    }
+
+    toml::table into_toml() const
+    {
+        return toml::table{{"a", this->a}, {"b", this->b}};
+    }
+};
+} // extlib
+
+namespace toml
+{
+template<>
+struct from<extlib::foo>
+{
+    static extlib::foo from_toml(const toml::value& v)
+    {
+        return extlib::foo{toml::find<int>(v, "a"), toml::find<std::string>(v, "b")};
+    }
+};
+
+template<>
+struct into<extlib::foo>
+{
+    static toml::table into_toml(const extlib::foo& f)
+    {
+        return toml::table{{"a", f.a}, {"b", f.b}};
+    }
+};
+} // toml
+
+
+BOOST_AUTO_TEST_CASE(test_conversion_by_member_methods)
+{
+    const toml::value v{{"a", 42}, {"b", "baz"}};
+
+    const auto foo = toml::get<extlib::foo>(v);
+    BOOST_CHECK_EQUAL(foo.a, 42);
+    BOOST_CHECK_EQUAL(foo.b, "baz");
+
+    const toml::value v2(foo);
+
+    BOOST_CHECK_EQUAL(v, v2);
+}
+
+BOOST_AUTO_TEST_CASE(test_conversion_by_specialization)
+{
+    const toml::value v{{"a", 42}, {"b", "baz"}};
+
+    const auto bar = toml::get<extlib::bar>(v);
+    BOOST_CHECK_EQUAL(bar.a, 42);
+    BOOST_CHECK_EQUAL(bar.b, "baz");
+
+    const toml::value v2(bar);
+
+    BOOST_CHECK_EQUAL(v, v2);
+}
+
+BOOST_AUTO_TEST_CASE(test_recursive_conversion)
+{
+    const toml::value v{
+        toml::table{{"a", 42}, {"b", "baz"}},
+        toml::table{{"a", 43}, {"b", "qux"}},
+        toml::table{{"a", 44}, {"b", "quux"}},
+        toml::table{{"a", 45}, {"b", "foobar"}},
+    };
+
+    const auto foos = toml::get<std::vector<extlib::foo>>(v);
+    BOOST_CHECK_EQUAL(foos.size()  , 4ul);
+    BOOST_CHECK_EQUAL(foos.at(0).a , 42);
+    BOOST_CHECK_EQUAL(foos.at(1).a , 43);
+    BOOST_CHECK_EQUAL(foos.at(2).a , 44);
+    BOOST_CHECK_EQUAL(foos.at(3).a , 45);
+
+    BOOST_CHECK_EQUAL(foos.at(0).b , "baz");
+    BOOST_CHECK_EQUAL(foos.at(1).b , "qux");
+    BOOST_CHECK_EQUAL(foos.at(2).b , "quux");
+    BOOST_CHECK_EQUAL(foos.at(3).b , "foobar");
+
+    const auto bars = toml::get<std::vector<extlib::bar>>(v);
+    BOOST_CHECK_EQUAL(bars.size()  , 4ul);
+    BOOST_CHECK_EQUAL(bars.at(0).a , 42);
+    BOOST_CHECK_EQUAL(bars.at(1).a , 43);
+    BOOST_CHECK_EQUAL(bars.at(2).a , 44);
+    BOOST_CHECK_EQUAL(bars.at(3).a , 45);
+
+    BOOST_CHECK_EQUAL(bars.at(0).b , "baz");
+    BOOST_CHECK_EQUAL(bars.at(1).b , "qux");
+    BOOST_CHECK_EQUAL(bars.at(2).b , "quux");
+    BOOST_CHECK_EQUAL(bars.at(3).b , "foobar");
+}
--- a/tests/test_format_error.cpp
+++ b/tests/test_format_error.cpp
@@ -22,7 +22,7 @@ BOOST_AUTO_TEST_CASE(test_1_value)
    {
        const std::string pretty_error =
            toml::format_error("[error] test error", val, "this is a value",
-                               std::vector<std::string>{"this is a hint"});
+                               {"this is a hint"});
        std::cout << pretty_error << std::endl;
    }
 }
@@ -44,7 +44,7 @@ BOOST_AUTO_TEST_CASE(test_2_values)
            toml::format_error("[error] test error with two values",
                               v1, "this is the answer",
                               v2, "this is the pi",
-                               std::vector<std::string>{"hint"});
+                               {"hint"});
        std::cout << pretty_error << std::endl;
    }
 }
@@ -69,7 +69,7 @@ BOOST_AUTO_TEST_CASE(test_3_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"});
+                               {"hint 1", "hint 2"});
        std::cout << pretty_error << std::endl;
    }
 }
--- a/tests/test_get_related_func.cpp
+++ b/tests/test_get_related_func.cpp
@@ -45,21 +45,194 @@ BOOST_AUTO_TEST_CASE(test_find)

 BOOST_AUTO_TEST_CASE(test_get_or)
 {
-    {
-        toml::table v{{"num", 42}};
-        BOOST_CHECK_EQUAL(42, toml::get_or<int>(v, "num", 0));
-        BOOST_CHECK_EQUAL(0,  toml::get_or<int>(v, "foo", 0));
-    }
-    {
-        toml::value v = toml::table{{"num", 42}};
-        BOOST_CHECK_EQUAL(42, toml::get_or<int>(v, "num", 0));
-        BOOST_CHECK_EQUAL(0,  toml::get_or<int>(v, "foo", 0));
-    }
+    // requires conversion int -> uint
    {
        toml::value v1(42);
        toml::value v2(3.14);
-        BOOST_CHECK_EQUAL(42, toml::get_or<int>(v1, 0));
-        BOOST_CHECK_EQUAL(0,  toml::get_or<int>(v2, 0));
+        BOOST_CHECK_EQUAL(42u, toml::get_or(v1, 0u));
+        BOOST_CHECK_EQUAL(0u,  toml::get_or(v2, 0u));
+    }
+
+    // exact toml type
+    {
+        toml::value v1(42);
+        toml::value v2(3.14);
+
+        toml::integer opt(0);
+        BOOST_CHECK_EQUAL(42, toml::get_or(v1, opt));
+        BOOST_CHECK_EQUAL(0,  toml::get_or(v2, opt));
+
+        toml::value v3("foobar");
+        toml::string s("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v3, s));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v1, s));
+
+    }
+
+    // std::string
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, s1));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, s1));
+
+        std::string& v1r = toml::get_or(v1, s1);
+        std::string& s1r = toml::get_or(v2, s1);
+
+        BOOST_CHECK_EQUAL("foobar", v1r);
+        BOOST_CHECK_EQUAL("bazqux", s1r);
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, s2));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, s2));
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, std::move(s1)));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, std::move(s1)));
+    }
+
+    // string literal
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, "bazqux"));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, "bazqux"));
+
+        const char* lit = "bazqux";
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, lit));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, lit));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_find_or)
+{
+    // ========================================================================
+    // pass toml::value
+    //
+    // requires conversion int -> uint
+    {
+        toml::table v{{"num", 42}};
+        BOOST_CHECK_EQUAL(42u, toml::find_or(v, "num", 0u));
+        BOOST_CHECK_EQUAL(0u,  toml::find_or(v, "foo", 0u));
+    }
+    // exact toml type
+    {
+        toml::table v1{{"key", 42  }};
+        toml::table v2{{"key", 3.14}};
+        toml::table v3{{"not", "key"}};
+
+        toml::integer opt(0);
+        BOOST_CHECK_EQUAL(42, toml::find_or(v1, "key", opt));
+        BOOST_CHECK_EQUAL(0,  toml::find_or(v2, "key", opt));
+        BOOST_CHECK_EQUAL(0,  toml::find_or(v3, "key", opt));
+
+        toml::table v4{{"str", "foobar"}};
+        toml::string s("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v4, "str", s));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v1, "str", s));
+    }
+    // std::string
+    {
+        toml::table v1{{"key", "foobar"}};
+        toml::table v2{{"key", 42}};
+
+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s1));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s1));
+
+        std::string& v1r = toml::find_or(v1, "key", s1);
+        std::string& s1r = toml::find_or(v2, "key", s1);
+
+        BOOST_CHECK_EQUAL("foobar", v1r);
+        BOOST_CHECK_EQUAL("bazqux", s1r);
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s2));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s2));
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(std::move(v1), "key", std::move(s1)));
+        s1 = "bazqux"; // restoring moved value
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(std::move(v2), "key", std::move(s1)));
+    }
+    // string literal
+    {
+        toml::table v1{{"key", "foobar"}};
+        toml::table v2{{"key",42}};
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", "bazqux"));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", "bazqux"));
+
+        const char* lit = "bazqux";
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", lit));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", lit));
+    }
+
+    // ========================================================================
+    // pass toml::value
+    //
+    // requires conversion int -> uint
+    {
+        toml::table v = toml::table{{"num", 42}};
+        BOOST_CHECK_EQUAL(42u, toml::find_or(v, "num", 0u));
+        BOOST_CHECK_EQUAL(0u,  toml::find_or(v, "foo", 0u));
+    }
+    // exact toml type
+    {
+        toml::value v1 = toml::table{{"key", 42  }};
+        toml::value v2 = toml::table{{"key", 3.14}};
+        toml::value v3 = toml::table{{"not", "key"}};
+
+        BOOST_CHECK_EQUAL(42, toml::find_or(v1, "key", toml::integer(0)));
+        BOOST_CHECK_EQUAL( 0, toml::find_or(v2, "key", toml::integer(0)));
+        BOOST_CHECK_EQUAL( 0, toml::find_or(v3, "key", toml::integer(0)));
+
+        toml::value v4 = toml::table{{"str", "foobar"}};
+        toml::string s("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v4, "str", s));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v1, "str", s));
+    }
+    // std::string
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key", 42}};
+
+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s1));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s1));
+
+        std::string& v1r = toml::find_or(v1, "key", s1);
+        std::string& s1r = toml::find_or(v2, "key", s1);
+
+        BOOST_CHECK_EQUAL("foobar", v1r);
+        BOOST_CHECK_EQUAL("bazqux", s1r);
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s2));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s2));
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(std::move(v1), "key", std::move(s1)));
+        s1 = "bazqux"; // restoring moved value
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(std::move(v2), "key", std::move(s1)));
+    }
+    // string literal
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key",42}};
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", "bazqux"));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", "bazqux"));
+
+        const char* lit = "bazqux";
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", lit));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", lit));
    }
 }

--- a/tests/test_literals.cpp
+++ b/tests/test_literals.cpp
@@ -0,0 +1,129 @@
+#define BOOST_TEST_MODULE "test_literals"
+#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 <map>
+
+BOOST_AUTO_TEST_CASE(test_file_as_literal)
+{
+    using namespace toml::literals::toml_literals;
+
+    {
+        const toml::value r{{"a", 42}, {"b", "baz"}};
+        const toml::value v = u8R"(
+            a = 42
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(r, v);
+    }
+    {
+        const toml::value r{
+            {"c", 3.14},
+            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
+        };
+        const toml::value v = u8R"(
+            c = 3.14
+            [table]
+            a = 42
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(r, v);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_value_as_literal)
+{
+    using namespace toml::literals::toml_literals;
+
+    {
+        const toml::value v1 = u8"true"_toml;
+        const toml::value v2 = u8"false"_toml;
+
+        BOOST_CHECK(v1.is_boolean());
+        BOOST_CHECK(v2.is_boolean());
+        BOOST_CHECK(toml::get<bool>(v1));
+        BOOST_CHECK(!toml::get<bool>(v2));
+    }
+    {
+        const toml::value v1 = u8"123_456"_toml;
+        const toml::value v2 = u8"0b0010"_toml;
+        const toml::value v3 = u8"0xDEADBEEF"_toml;
+
+        BOOST_CHECK(v1.is_integer());
+        BOOST_CHECK(v2.is_integer());
+        BOOST_CHECK(v3.is_integer());
+        BOOST_CHECK_EQUAL(toml::get<toml::integer>(v1), 123456);
+        BOOST_CHECK_EQUAL(toml::get<toml::integer>(v2), 2);
+        BOOST_CHECK_EQUAL(toml::get<toml::integer>(v3), 0xDEADBEEF);
+    }
+    {
+        const toml::value v1 = u8"3.1415"_toml;
+        const toml::value v2 = u8"6.02e+23"_toml;
+
+        BOOST_CHECK(v1.is_float());
+        BOOST_CHECK(v2.is_float());
+        BOOST_CHECK_CLOSE(toml::get<double>(v1), 3.1415,  0.00001);
+        BOOST_CHECK_CLOSE(toml::get<double>(v2), 6.02e23, 0.0001);
+    }
+    {
+        const toml::value v1 = u8R"("foo")"_toml;
+        const toml::value v2 = u8R"('foo')"_toml;
+        const toml::value v3 = u8R"("""foo""")"_toml;
+        const toml::value v4 = u8R"('''foo''')"_toml;
+
+        BOOST_CHECK(v1.is_string());
+        BOOST_CHECK(v2.is_string());
+        BOOST_CHECK(v3.is_string());
+        BOOST_CHECK(v4.is_string());
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v1), "foo");
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v2), "foo");
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v3), "foo");
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v4), "foo");
+    }
+    {
+        const toml::value v1 = u8R"([1,2,3])"_toml;
+
+        BOOST_CHECK(v1.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(v1) == std::vector<int>{1,2,3}));
+    }
+    {
+        const toml::value v1 = u8R"({a = 42})"_toml;
+
+        BOOST_CHECK(v1.is_table());
+        BOOST_CHECK((toml::get<std::map<std::string,int>>(v1) ==
+                               std::map<std::string,int>{{"a", 42}}));
+    }
+    {
+        const toml::value v1 = u8"1979-05-27"_toml;
+
+        BOOST_CHECK(v1.is_local_date());
+        BOOST_CHECK_EQUAL(toml::get<toml::local_date>(v1),
+                          toml::local_date(1979, toml::month_t::May, 27));
+    }
+    {
+        const toml::value v1 = u8"12:00:00"_toml;
+
+        BOOST_CHECK(v1.is_local_time());
+        BOOST_CHECK(toml::get<std::chrono::hours>(v1) == std::chrono::hours(12));
+    }
+    {
+        const toml::value v1 = u8"1979-05-27T07:32:00"_toml;
+        BOOST_CHECK(v1.is_local_datetime());
+        BOOST_CHECK_EQUAL(toml::get<toml::local_datetime>(v1),
+            toml::local_datetime(toml::local_date(1979, toml::month_t::May, 27),
+                                 toml::local_time(7, 32, 0)));
+    }
+    {
+        const toml::value v1 = "1979-05-27T07:32:00Z"_toml;
+        BOOST_CHECK(v1.is_offset_datetime());
+        BOOST_CHECK_EQUAL(toml::get<toml::offset_datetime>(v1),
+            toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
+                                  toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
+    }
+}
--- a/tests/test_multiple_translation_unit_1.cpp
+++ b/tests/test_multiple_translation_unit_1.cpp
@@ -0,0 +1,11 @@
+#include <toml.hpp>
+
+int read_a(const toml::table&);
+
+int main()
+{
+    const std::string content("a = 0");
+    std::istringstream iss(content);
+    const auto data = toml::parse(iss, "test_multiple_translation_unit.toml");
+    return read_a(data);
+}
--- a/tests/test_multiple_translation_unit_2.cpp
+++ b/tests/test_multiple_translation_unit_2.cpp
@@ -0,0 +1,6 @@
+#include <toml.hpp>
+
+int read_a(const toml::table& t)
+{
+    return toml::get<int>(t.at("a"));
+}
--- a/tests/test_to_toml.cpp
+++ b/tests/test_to_toml.cpp
@@ -1,189 +0,0 @@
-#define BOOST_TEST_MODULE "test_to_toml"
-#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 <map>
-#include <list>
-
-BOOST_AUTO_TEST_CASE(test_value_boolean)
-{
-    toml::value v1 = toml::to_toml(true);
-    toml::value v2 = toml::to_toml(false);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Boolean);
-    BOOST_CHECK(v1.is(toml::value_t::Boolean));
-    BOOST_CHECK(v2.is(toml::value_t::Boolean));
-    BOOST_CHECK(v1.is<toml::Boolean>());
-    BOOST_CHECK(v2.is<toml::Boolean>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
-}
-
-BOOST_AUTO_TEST_CASE(test_value_integer)
-{
-    toml::value v1 = toml::to_toml(-42);
-    toml::value v2 = toml::to_toml(42u);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Integer);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Integer);
-    BOOST_CHECK(v1.is(toml::value_t::Integer));
-    BOOST_CHECK(v2.is(toml::value_t::Integer));
-    BOOST_CHECK(v1.is<toml::Integer>());
-    BOOST_CHECK(v2.is<toml::Integer>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), -42);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(),  42u);
-}
-
-BOOST_AUTO_TEST_CASE(test_value_float)
-{
-    toml::value v1 = toml::to_toml(3.14);
-    toml::value v2 = toml::to_toml(3.14f);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Float);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Float);
-    BOOST_CHECK(v1.is(toml::value_t::Float));
-    BOOST_CHECK(v2.is(toml::value_t::Float));
-    BOOST_CHECK(v1.is<toml::Float>());
-    BOOST_CHECK(v2.is<toml::Float>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Float>(), 3.14);
-    BOOST_CHECK_CLOSE_FRACTION(v2.cast<toml::value_t::Float>(), 3.14, 1e-2);
-}
-
-BOOST_AUTO_TEST_CASE(test_value_string)
-{
-    toml::value v1 = toml::to_toml(std::string("foo"));
-    toml::value v2 = toml::to_toml(std::string("foo"), toml::string_t::literal);
-    toml::value v3 = toml::to_toml("foo");
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::String);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::String);
-    BOOST_CHECK_EQUAL(v3.type(), toml::value_t::String);
-    BOOST_CHECK(v1.is(toml::value_t::String));
-    BOOST_CHECK(v2.is(toml::value_t::String));
-    BOOST_CHECK(v3.is(toml::value_t::String));
-    BOOST_CHECK(v1.is<toml::String>());
-    BOOST_CHECK(v2.is<toml::String>());
-    BOOST_CHECK(v3.is<toml::String>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::String>(), "foo");
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::String>(), "foo");
-    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::String>(), "foo");
-}
-
-BOOST_AUTO_TEST_CASE(test_value_local_date)
-{
-    toml::value v1 = toml::to_toml(toml::local_date(2018, toml::month_t::Jan, 31));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDate);
-    BOOST_CHECK(v1.is(toml::value_t::LocalDate));
-    BOOST_CHECK(v1.is<toml::LocalDate>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
-                      toml::local_date(2018, toml::month_t::Jan, 31));
-}
-
-BOOST_AUTO_TEST_CASE(test_value_local_time)
-{
-    toml::value v1 = toml::to_toml(toml::local_time(12, 30, 45));
-    toml::value v2 = toml::to_toml(std::chrono::hours(12) + std::chrono::minutes(30) +
-                   std::chrono::seconds(45));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalTime);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::LocalTime);
-    BOOST_CHECK(v1.is(toml::value_t::LocalTime));
-    BOOST_CHECK(v2.is(toml::value_t::LocalTime));
-    BOOST_CHECK(v1.is<toml::LocalTime>());
-    BOOST_CHECK(v2.is<toml::LocalTime>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
-                      toml::local_time(12, 30, 45));
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalTime>(),
-                      toml::local_time(12, 30, 45));
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
-                      v2.cast<toml::value_t::LocalTime>());
-}
-
-BOOST_AUTO_TEST_CASE(test_value_local_datetime)
-{
-    toml::value v1 = toml::to_toml(toml::local_datetime(
-                toml::local_date(2018, toml::month_t::Jan, 31),
-                toml::local_time(12, 30, 45)
-                ));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDatetime);
-    BOOST_CHECK(v1.is(toml::value_t::LocalDatetime));
-    BOOST_CHECK(v1.is<toml::LocalDatetime>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDatetime>(),
-                      toml::local_datetime(
-                          toml::local_date(2018, toml::month_t::Jan, 31),
-                          toml::local_time(12, 30, 45)));
-}
-
-BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
-{
-    toml::value v1 = toml::to_toml(toml::offset_datetime(
-                toml::local_date(2018, toml::month_t::Jan, 31),
-                toml::local_time(12, 30, 45),
-                toml::time_offset(9, 0)
-                ));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::OffsetDatetime);
-    BOOST_CHECK(v1.is(toml::value_t::OffsetDatetime));
-    BOOST_CHECK(v1.is<toml::OffsetDatetime>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::OffsetDatetime>(),
-            toml::offset_datetime(
-                toml::local_date(2018, toml::month_t::Jan, 31),
-                toml::local_time(12, 30, 45),
-                toml::time_offset(9, 0)
-                ));
-}
-
-BOOST_AUTO_TEST_CASE(test_value_array)
-{
-    std::vector<int> v{1,2,3,4,5};
-    toml::value v1 = toml::to_toml(v);
-    toml::value v2 = toml::to_toml(6,7,8,9,0);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Array);
-    BOOST_CHECK(v1.is(toml::value_t::Array));
-    BOOST_CHECK(v1.is<toml::Array>());
-
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Array);
-    BOOST_CHECK(v2.is(toml::value_t::Array));
-    BOOST_CHECK(v2.is<toml::Array>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 1);
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 2);
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 3);
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 4);
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 5);
-
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 6);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 7);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 8);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 9);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 0);
-}
-
-BOOST_AUTO_TEST_CASE(test_value_table)
-{
-    toml::value v1 = toml::to_toml({{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}});
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Table);
-    BOOST_CHECK(v1.is(toml::value_t::Table));
-    BOOST_CHECK(v1.is<toml::Table>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Integer>(),    42);
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Float>(),      3.14);
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("baz").cast<toml::value_t::String>().str, "qux");
-}
--- a/tests/test_value.cpp
+++ b/tests/test_value.cpp
@@ -20,6 +20,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
    BOOST_CHECK(v2.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_boolean());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
@@ -33,6 +35,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
    BOOST_CHECK(v2.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_boolean());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), false);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), true);
@@ -48,6 +52,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
    BOOST_CHECK(v4.is(toml::value_t::Boolean));
    BOOST_CHECK(v3.is<toml::Boolean>());
    BOOST_CHECK(v4.is<toml::Boolean>());
+    BOOST_CHECK(v3.is_boolean());
+    BOOST_CHECK(v4.is_boolean());

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Boolean>(), false);
    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Boolean>(), true);
@@ -61,6 +67,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
    BOOST_CHECK(v6.is(toml::value_t::Boolean));
    BOOST_CHECK(v5.is<toml::Boolean>());
    BOOST_CHECK(v6.is<toml::Boolean>());
+    BOOST_CHECK(v3.is_boolean());
+    BOOST_CHECK(v4.is_boolean());

    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::Boolean>(), false);
    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Boolean>(), true);
@@ -74,6 +82,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
    BOOST_CHECK(v2.is(toml::value_t::Float));
    BOOST_CHECK(v1.is<toml::Integer>());
    BOOST_CHECK(v2.is<toml::Float>());
+    BOOST_CHECK(v1.is_integer());
+    BOOST_CHECK(v2.is_float());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), 42);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Float>(),   3.14);
@@ -90,6 +100,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
    BOOST_CHECK(v2.is(toml::value_t::Integer));
    BOOST_CHECK(v1.is<toml::Integer>());
    BOOST_CHECK(v2.is<toml::Integer>());
+    BOOST_CHECK(v1.is_integer());
+    BOOST_CHECK(v2.is_integer());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), -42);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(),  42u);
@@ -103,6 +115,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
    BOOST_CHECK(v2.is(toml::value_t::Integer));
    BOOST_CHECK(v1.is<toml::Integer>());
    BOOST_CHECK(v2.is<toml::Integer>());
+    BOOST_CHECK(v1.is_integer());
+    BOOST_CHECK(v2.is_integer());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(),  54);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(), -54);
@@ -118,6 +132,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
    BOOST_CHECK(v4.is(toml::value_t::Integer));
    BOOST_CHECK(v3.is<toml::Integer>());
    BOOST_CHECK(v4.is<toml::Integer>());
+    BOOST_CHECK(v3.is_integer());
+    BOOST_CHECK(v4.is_integer());

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Integer>(),  54);
    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Integer>(), -54);
@@ -131,6 +147,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
    BOOST_CHECK(v6.is(toml::value_t::Integer));
    BOOST_CHECK(v5.is<toml::Integer>());
    BOOST_CHECK(v6.is<toml::Integer>());
+    BOOST_CHECK(v5.is_integer());
+    BOOST_CHECK(v6.is_integer());

    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::Integer>(),  54);
    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Integer>(), -54);
@@ -144,6 +162,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
    BOOST_CHECK(v2.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_boolean());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
@@ -160,6 +180,8 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v2.is(toml::value_t::Float));
    BOOST_CHECK(v1.is<toml::Float>());
    BOOST_CHECK(v2.is<toml::Float>());
+    BOOST_CHECK(v1.is_float());
+    BOOST_CHECK(v2.is_float());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Float>(), 3.14);
    BOOST_CHECK_CLOSE_FRACTION(v2.cast<toml::value_t::Float>(), 3.14, 1e-2);
@@ -173,6 +195,8 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v2.is(toml::value_t::Float));
    BOOST_CHECK(v1.is<toml::Float>());
    BOOST_CHECK(v2.is<toml::Float>());
+    BOOST_CHECK(v1.is_float());
+    BOOST_CHECK(v2.is_float());

    BOOST_CHECK_CLOSE_FRACTION(v1.cast<toml::value_t::Float>(), 2.718, 1e-3);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Float>(), 2.718);
@@ -188,6 +212,8 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v4.is(toml::value_t::Float));
    BOOST_CHECK(v3.is<toml::Float>());
    BOOST_CHECK(v4.is<toml::Float>());
+    BOOST_CHECK(v3.is_float());
+    BOOST_CHECK(v4.is_float());

    BOOST_CHECK_CLOSE_FRACTION(v3.cast<toml::value_t::Float>(), 2.718, 1e-3);
    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Float>(), 2.718);
@@ -201,6 +227,8 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v6.is(toml::value_t::Float));
    BOOST_CHECK(v5.is<toml::Float>());
    BOOST_CHECK(v6.is<toml::Float>());
+    BOOST_CHECK(v5.is_float());
+    BOOST_CHECK(v6.is_float());

    BOOST_CHECK_CLOSE_FRACTION(v5.cast<toml::value_t::Float>(), 2.718, 1e-3);
    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Float>(), 2.718);
@@ -214,6 +242,8 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v2.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_boolean());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
@@ -234,6 +264,9 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK(v1.is<toml::String>());
    BOOST_CHECK(v2.is<toml::String>());
    BOOST_CHECK(v3.is<toml::String>());
+    BOOST_CHECK(v1.is_string());
+    BOOST_CHECK(v2.is_string());
+    BOOST_CHECK(v3.is_string());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::String>(), "foo");
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::String>(), "foo");
@@ -249,9 +282,9 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK(v1.is(toml::value_t::String));
    BOOST_CHECK(v2.is(toml::value_t::String));
    BOOST_CHECK(v3.is(toml::value_t::String));
-    BOOST_CHECK(v1.is<toml::String>());
-    BOOST_CHECK(v2.is<toml::String>());
-    BOOST_CHECK(v3.is<toml::String>());
+    BOOST_CHECK(v1.is_string());
+    BOOST_CHECK(v2.is_string());
+    BOOST_CHECK(v3.is_string());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::String>(), "bar");
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::String>(), "bar");
@@ -273,6 +306,9 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK(v4.is<toml::String>());
    BOOST_CHECK(v5.is<toml::String>());
    BOOST_CHECK(v6.is<toml::String>());
+    BOOST_CHECK(v4.is_string());
+    BOOST_CHECK(v5.is_string());
+    BOOST_CHECK(v6.is_string());

    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::String>(), "bar");
    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::String>(), "bar");
@@ -291,6 +327,9 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK(v4.is<toml::String>());
    BOOST_CHECK(v5.is<toml::String>());
    BOOST_CHECK(v6.is<toml::String>());
+    BOOST_CHECK(v4.is_string());
+    BOOST_CHECK(v5.is_string());
+    BOOST_CHECK(v6.is_string());

    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::String>(), "baz");
    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::String>(), "baz");
@@ -309,6 +348,9 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v2.is<toml::Boolean>());
    BOOST_CHECK(v3.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_boolean());
+    BOOST_CHECK(v3.is_boolean());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), true);
@@ -322,6 +364,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDate);
    BOOST_CHECK(v1.is(toml::value_t::LocalDate));
    BOOST_CHECK(v1.is<toml::LocalDate>());
+    BOOST_CHECK(v1.is_local_date());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
                      toml::local_date(2018, toml::month_t::Jan, 31));
@@ -331,6 +374,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDate);
    BOOST_CHECK(v1.is(toml::value_t::LocalDate));
    BOOST_CHECK(v1.is<toml::LocalDate>());
+    BOOST_CHECK(v1.is_local_date());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
                      toml::local_date(2018, toml::month_t::Apr, 1));
@@ -341,6 +385,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::LocalDate);
    BOOST_CHECK(v2.is(toml::value_t::LocalDate));
    BOOST_CHECK(v2.is<toml::LocalDate>());
+    BOOST_CHECK(v2.is_local_date());

    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalDate>(),
                      toml::local_date(2018, toml::month_t::Apr, 1));
@@ -349,6 +394,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
    BOOST_CHECK(v1.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
 }

@@ -364,6 +410,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
    BOOST_CHECK(v2.is(toml::value_t::LocalTime));
    BOOST_CHECK(v1.is<toml::LocalTime>());
    BOOST_CHECK(v2.is<toml::LocalTime>());
+    BOOST_CHECK(v1.is_local_time());
+    BOOST_CHECK(v2.is_local_time());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                      toml::local_time(12, 30, 45));
@@ -377,6 +425,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalTime);
    BOOST_CHECK(v1.is(toml::value_t::LocalTime));
    BOOST_CHECK(v1.is<toml::LocalTime>());
+    BOOST_CHECK(v1.is_local_time());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                      toml::local_time(1, 30, 0, 100, 0));

@@ -386,6 +435,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
    BOOST_CHECK_EQUAL(v3.type(), toml::value_t::LocalTime);
    BOOST_CHECK(v3.is(toml::value_t::LocalTime));
    BOOST_CHECK(v3.is<toml::LocalTime>());
+    BOOST_CHECK(v3.is_local_time());

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::LocalTime>(),
                      toml::local_time(1, 30, 0, 100, 0));
@@ -394,6 +444,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
    BOOST_CHECK(v1.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
 }

@@ -407,6 +458,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDatetime);
    BOOST_CHECK(v1.is(toml::value_t::LocalDatetime));
    BOOST_CHECK(v1.is<toml::LocalDatetime>());
+    BOOST_CHECK(v1.is_local_datetime());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDatetime>(),
                      toml::local_datetime(
@@ -420,6 +472,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDatetime);
    BOOST_CHECK(v1.is(toml::value_t::LocalDatetime));
    BOOST_CHECK(v1.is<toml::LocalDatetime>());
+    BOOST_CHECK(v1.is_local_datetime());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDatetime>(),
                      toml::local_datetime(
@@ -432,6 +485,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::LocalDatetime);
    BOOST_CHECK(v2.is(toml::value_t::LocalDatetime));
    BOOST_CHECK(v2.is<toml::LocalDatetime>());
+    BOOST_CHECK(v2.is_local_datetime());

    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalDatetime>(),
                      toml::local_datetime(
@@ -442,6 +496,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
    BOOST_CHECK(v1.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
 }

@@ -456,6 +511,7 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::OffsetDatetime);
    BOOST_CHECK(v1.is(toml::value_t::OffsetDatetime));
    BOOST_CHECK(v1.is<toml::OffsetDatetime>());
+    BOOST_CHECK(v1.is_offset_datetime());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::OffsetDatetime>(),
            toml::offset_datetime(
@@ -472,6 +528,7 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::OffsetDatetime);
    BOOST_CHECK(v1.is(toml::value_t::OffsetDatetime));
    BOOST_CHECK(v1.is<toml::OffsetDatetime>());
+    BOOST_CHECK(v1.is_offset_datetime());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::OffsetDatetime>(),
            toml::offset_datetime(
@@ -485,6 +542,7 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::OffsetDatetime);
    BOOST_CHECK(v2.is(toml::value_t::OffsetDatetime));
    BOOST_CHECK(v2.is<toml::OffsetDatetime>());
+    BOOST_CHECK(v2.is_offset_datetime());

    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::OffsetDatetime>(),
            toml::offset_datetime(
@@ -495,6 +553,7 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
    BOOST_CHECK(v1.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
 }

@@ -507,10 +566,12 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Array);
    BOOST_CHECK(v1.is(toml::value_t::Array));
    BOOST_CHECK(v1.is<toml::Array>());
+    BOOST_CHECK(v1.is_array());

    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Array);
    BOOST_CHECK(v2.is(toml::value_t::Array));
    BOOST_CHECK(v2.is<toml::Array>());
+    BOOST_CHECK(v2.is_array());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 1);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 2);
@@ -530,10 +591,12 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Array);
    BOOST_CHECK(v1.is(toml::value_t::Array));
    BOOST_CHECK(v1.is<toml::Array>());
+    BOOST_CHECK(v1.is_array());

    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Array);
    BOOST_CHECK(v2.is(toml::value_t::Array));
    BOOST_CHECK(v2.is<toml::Array>());
+    BOOST_CHECK(v2.is_array());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 6);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 7);
@@ -553,6 +616,7 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK_EQUAL(v3.type(), toml::value_t::Array);
    BOOST_CHECK(v3.is(toml::value_t::Array));
    BOOST_CHECK(v3.is<toml::Array>());
+    BOOST_CHECK(v3.is_array());

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 6);
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 7);
@@ -564,6 +628,7 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
    BOOST_CHECK(v1.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
 }

@@ -574,6 +639,7 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Table);
    BOOST_CHECK(v1.is(toml::value_t::Table));
    BOOST_CHECK(v1.is<toml::Table>());
+    BOOST_CHECK(v1.is_table());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Integer>(),    42);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Float>(),      3.14);
@@ -584,6 +650,7 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Table);
    BOOST_CHECK(v1.is(toml::value_t::Table));
    BOOST_CHECK(v1.is<toml::Table>());
+    BOOST_CHECK(v1.is_table());

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Float>(),      2.71);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Integer>(),    54);
@@ -595,6 +662,7 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK_EQUAL(v3.type(), toml::value_t::Table);
    BOOST_CHECK(v3.is(toml::value_t::Table));
    BOOST_CHECK(v3.is<toml::Table>());
+    BOOST_CHECK(v3.is_table());

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Float>(),      2.71);
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Integer>(),    54);
@@ -604,5 +672,13 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
    BOOST_CHECK(v1.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
 }
+
+BOOST_AUTO_TEST_CASE(test_value_empty)
+{
+    toml::value v1;
+    BOOST_CHECK(v1.is_uninitialized());
+    BOOST_CHECK(v1.is(toml::value_t::Empty));
+}
--- a/toml.hpp
+++ b/toml.hpp
@@ -34,8 +34,8 @@
 #endif

 #include "toml/parser.hpp"
+#include "toml/literal.hpp"
 #include "toml/serializer.hpp"
-#include "toml/to_toml.hpp"
 #include "toml/from_toml.hpp"
 #include "toml/get.hpp"

--- a/toml/datetime.hpp
+++ b/toml/datetime.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_DATETIME
-#define TOML11_DATETIME
+#ifndef TOML11_DATETIME_HPP
+#define TOML11_DATETIME_HPP
 #include <chrono>
 #include <tuple>
 #include <array>
@@ -332,17 +332,10 @@ operator<<(std::basic_ostream<charT, traits>& os, const time_offset& offset)
        os << 'Z';
        return os;
    }
-    if(static_cast<int>(offset.hour) * static_cast<int>(offset.minute) < 0)
-    {
-        const int min = static_cast<int>(offset.hour) * 60 + offset.minute;
-        if(min < 0){os << '-';} else {os << '+';}
-        os << std::setfill('0') << std::setw(2) << min / 60 << ':';
-        os << std::setfill('0') << std::setw(2) << min % 60;
-        return os;
-    }
-    if(offset.hour < 0){os << '-';} else {os << '+';}
-    os << std::setfill('0') << std::setw(2) << static_cast<int>(offset.hour) << ':';
-    os << std::setfill('0') << std::setw(2) << static_cast<int>(offset.minute);
+    int minute = static_cast<int>(offset.hour) * 60 + offset.minute;
+    if(minute < 0){os << '-'; minute = std::abs(minute);} else {os << '+';}
+    os << std::setfill('0') << std::setw(2) << minute / 60 << ':';
+    os << std::setfill('0') << std::setw(2) << minute % 60;
    return os;
 }

--- a/toml/exception.hpp
+++ b/toml/exception.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_EXCEPTION
-#define TOML11_EXCEPTION
+#ifndef TOML11_EXCEPTION_HPP
+#define TOML11_EXCEPTION_HPP
 #include <stdexcept>
 #include <string>

--- a/toml/from.hpp
+++ b/toml/from.hpp
@@ -0,0 +1,20 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_FROM_HPP
+#define TOML11_FROM_HPP
+#include "traits.hpp"
+
+namespace toml
+{
+
+template<typename T>
+struct from;
+// {
+//     static T from_toml(const toml::value& v)
+//     {
+//         // User-defined conversions ...
+//     }
+// };
+
+} // toml
+#endif // TOML11_FROM_HPP
--- a/toml/from_toml.hpp
+++ b/toml/from_toml.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_FROM_TOML
-#define TOML11_FROM_TOML
+#ifndef TOML11_FROM_TOML_HPP
+#define TOML11_FROM_TOML_HPP
 #include "get.hpp"

 namespace toml
--- a/toml/get.hpp
+++ b/toml/get.hpp
@@ -1,7 +1,8 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_GET
-#define TOML11_GET
+#ifndef TOML11_GET_HPP
+#define TOML11_GET_HPP
+#include "from.hpp"
 #include "result.hpp"
 #include "value.hpp"
 #include <algorithm>
@@ -112,7 +113,7 @@ inline std::string get(value&& v)

 template<typename T, typename std::enable_if<
    detail::is_chrono_duration<T>::value, std::nullptr_t>::type = nullptr>
-inline T get(value& v)
+inline T get(const value& v)
 {
    return std::chrono::duration_cast<T>(
            std::chrono::nanoseconds(v.cast<value_t::LocalTime>()));
@@ -124,7 +125,7 @@ inline T get(value& v)
 template<typename T, typename std::enable_if<
    std::is_same<std::chrono::system_clock::time_point, T>::value,
    std::nullptr_t>::type = nullptr>
-inline T get(value& v)
+inline T get(const value& v)
 {
    switch(v.type())
    {
@@ -173,6 +174,20 @@ template<typename T, typename std::enable_if<detail::conjunction<
    >::value, std::nullptr_t>::type = nullptr>
 T get(const toml::value& v);

+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+    detail::has_from_toml_method<T>, // but has from_toml(toml::value) memfn
+    std::is_default_constructible<T> // and default constructible
+    >::value, std::nullptr_t>::type = nullptr>
+T get(const toml::value& v);
+
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>> // not a toml::value
+    >::value, std::nullptr_t>::type = nullptr,
+    std::size_t = sizeof(::toml::from<T>) // and has from<T> specialization
+    >
+T get(const toml::value& v);
+
 // ============================================================================
 // array-like types; most likely STL container, like std::vector, etc.

@@ -297,6 +312,29 @@ T get(const toml::value& v)
    return map;
 }

+
+// ============================================================================
+// user-defined, but compatible types.
+
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+    detail::has_from_toml_method<T>, // but has from_toml(toml::value) memfn
+    std::is_default_constructible<T> // and default constructible
+    >::value, std::nullptr_t>::type>
+T get(const toml::value& v)
+{
+    T ud;
+    ud.from_toml(v);
+    return ud;
+}
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>> // not a toml::value
+    >::value, std::nullptr_t>::type, std::size_t>   // and has from<T>
+T get(const toml::value& v)
+{
+    return ::toml::from<T>::from_toml(v);
+}
+
 // ============================================================================
 // find and get

@@ -382,13 +420,14 @@ find(toml::value&& v, const toml::key& ky)


 // ============================================================================
-// get_or
+// get_or(value, fallback)

-template<typename T>
-decltype(::toml::get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(
-        std::declval<const toml::value&>()))
-get_or(const toml::value& v, T&& opt)
+// ----------------------------------------------------------------------------
+// specialization for the exact toml types (return type becomes lvalue ref)
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T const& get_or(const toml::value& v, const T& opt)
 {
    try
    {
@@ -397,14 +436,12 @@ get_or(const toml::value& v, T&& opt)
    }
    catch(...)
    {
-        return std::forward<T>(opt);
+        return opt;
    }
 }
-template<typename T>
-decltype(::toml::get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(
-        std::declval<toml::value&>()))
-get_or(toml::value& v, T&& opt)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T& get_or(toml::value& v, T& opt)
 {
    try
    {
@@ -413,77 +450,333 @@ get_or(toml::value& v, T&& opt)
    }
    catch(...)
    {
-        return std::forward<T>(opt);
+        return opt;
    }
 }
-template<typename T>
-decltype(::toml::get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(
-        std::declval<toml::value&&>()))
-get_or(toml::value&& v, T&& opt)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T&& get_or(toml::value&& v, T&& opt)
 {
    try
    {
        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(std::move(v));
+            typename std::remove_reference<T>::type>::type>(v);
    }
    catch(...)
    {
-        return std::forward<T>(opt);
+        return opt;
    }
 }

+// ----------------------------------------------------------------------------
+// specialization for std::string (return type becomes lvalue ref)
+
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string const& get_or(const toml::value& v, const T& opt)
+{
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string& get_or(toml::value& v, T& opt)
+{
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string get_or(toml::value&& v, T&& opt)
+{
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename T, typename std::enable_if<
+    detail::is_string_literal<typename std::remove_reference<T>::type>::value,
+    std::nullptr_t>::type = nullptr>
+std::string get_or(const toml::value& v, T&& opt)
+{
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return std::string(opt);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// others (require type conversion and return type cannot be lvalue reference)
+
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>,
+    detail::negation<std::is_same<T, std::string>>,
+    detail::negation<detail::is_string_literal<typename std::remove_reference<T>::type>>
+    >::value, std::nullptr_t>::type = nullptr>
+T get_or(const toml::value& v, T&& opt)
+{
+    try
+    {
+        return get<typename std::remove_cv<
+            typename std::remove_reference<T>::type>::type>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+
+// ===========================================================================
+// get_or(table, key, fallback)
+//
+// DEPRECATED: use find_or instead.

 template<typename T>
+TOML11_MARK_AS_DEPRECATED("use toml::find_or(table, key, opt) instead.")
 auto get_or(const toml::table& tab, const toml::key& ky, T&& opt)
    -> decltype(get_or(std::declval<value const&>(), std::forward<T>(opt)))
 {
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    if(tab.count(ky) == 0) {return opt;}
    return ::toml::get_or(tab.at(ky), std::forward<T>(opt));
 }
 template<typename T>
+TOML11_MARK_AS_DEPRECATED("use toml::find_or(table, key, opt) instead.")
 auto get_or(toml::table& tab, const toml::key& ky, T&& opt)
    -> decltype(get_or(std::declval<value&>(), std::forward<T>(opt)))
 {
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    if(tab.count(ky) == 0) {return opt;}
    return ::toml::get_or(tab[ky], std::forward<T>(opt));
 }
 template<typename T>
+TOML11_MARK_AS_DEPRECATED("use toml::find_or(table, key, opt) instead.")
 auto get_or(toml::table&& tab, const toml::key& ky, T&& opt)
    -> decltype(get_or(std::declval<value&&>(), std::forward<T>(opt)))
 {
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    if(tab.count(ky) == 0) {return opt;}
    return ::toml::get_or(std::move(tab[ky]), std::forward<T>(opt));
 }

 template<typename T>
+TOML11_MARK_AS_DEPRECATED("use toml::find_or(value, key, opt) instead.")
 auto get_or(const toml::value& v, const toml::key& ky, T&& opt)
    -> decltype(get_or(std::declval<value const&>(), std::forward<T>(opt)))
 {
-    if(v.type() != toml::value_t::Table){return std::forward<T>(opt);}
+    if(!v.is_table()) {return opt;}
    const auto& tab = toml::get<toml::table>(v);
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    if(tab.count(ky) == 0) {return opt;}
    return ::toml::get_or(tab.at(ky), std::forward<T>(opt));
 }
 template<typename T>
+TOML11_MARK_AS_DEPRECATED("use toml::find_or(value, key, opt) instead.")
 auto get_or(toml::value& v, const toml::key& ky, T&& opt)
    -> decltype(get_or(std::declval<value&>(), std::forward<T>(opt)))
 {
-    if(v.type() != toml::value_t::Table){return std::forward<T>(opt);}
+    if(!v.is_table()) {return opt;}
    auto& tab = toml::get<toml::table>(v);
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    if(tab.count(ky) == 0) {return opt;}
    return ::toml::get_or(tab[ky], std::forward<T>(opt));
 }
 template<typename T>
+TOML11_MARK_AS_DEPRECATED("use toml::find_or(value, key, opt) instead.")
 auto get_or(toml::value&& v, const toml::key& ky, T&& opt)
    -> decltype(get_or(std::declval<value&&>(), std::forward<T>(opt)))
 {
-    if(v.type() != toml::value_t::Table){return std::forward<T>(opt);}
+    if(!v.is_table()) {return opt;}
    auto tab = toml::get<toml::table>(std::move(v));
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    if(tab.count(ky) == 0) {return opt;}
    return ::toml::get_or(std::move(tab[ky]), std::forward<T>(opt));
 }

+// ===========================================================================
+// find_or(value, key, fallback)
+
+// ---------------------------------------------------------------------------
+// exact types (return type can be a reference)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T const& find_or(const toml::value& v, const toml::key& ky, const T& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
+}
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T& find_or(toml::value& v, const toml::key& ky, T& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
+}
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T&& find_or(toml::value&& v, const toml::key& ky, T&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto tab = toml::get<toml::table>(std::move(v));
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// std::string (return type can be a reference)
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string const& find_or(const toml::value& v, const toml::key& ky, const T& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string& find_or(toml::value& v, const toml::key& ky, T& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string find_or(toml::value&& v, const toml::key& ky, T&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto tab = toml::get<toml::table>(std::move(v));
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// string literal (deduced as std::string)
+template<typename T, typename std::enable_if<
+    detail::is_string_literal<typename std::remove_reference<T>::type>::value,
+    std::nullptr_t>::type = nullptr>
+std::string find_or(const toml::value& v, const toml::key& ky, T&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return std::string(opt);}
+    return get_or(tab.at(ky), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// others (require type conversion and return type cannot be lvalue reference)
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>,
+    detail::negation<std::is_same<T, std::string>>,
+    detail::negation<detail::is_string_literal<typename std::remove_reference<T>::type>>
+    >::value, std::nullptr_t>::type = nullptr>
+T find_or(const toml::value& v, const toml::key& ky, T&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), std::forward<T>(opt));
+}
+
+// ===========================================================================
+// find_or(table, key, opt)
+
+// ---------------------------------------------------------------------------
+// exact types (return type can be a reference)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T const& find_or(const toml::table& tab, const toml::key& ky, const T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
+}
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T& find_or(toml::table& tab, const toml::key& ky, T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
+}
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T&& find_or(toml::table&& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// std::string (return type can be a reference)
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string const& find_or(const toml::table& tab, const toml::key& ky, const T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string& find_or(toml::table& tab, const toml::key& ky, T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string find_or(toml::table&& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// string literal (deduced as std::string)
+template<typename T, typename std::enable_if<
+    detail::is_string_literal<typename std::remove_reference<T>::type>::value,
+    std::nullptr_t>::type = nullptr>
+std::string find_or(const toml::table& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return std::string(opt);}
+    return get_or(tab.at(ky), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// others (require type conversion and return type cannot be lvalue reference)
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>,
+    detail::negation<std::is_same<T, std::string>>,
+    detail::negation<detail::is_string_literal<typename std::remove_reference<T>::type>>
+    >::value, std::nullptr_t>::type = nullptr>
+T find_or(const toml::table& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), std::forward<T>(opt));
+}
+
 // ============================================================================
 // expect

--- a/toml/into.hpp
+++ b/toml/into.hpp
@@ -0,0 +1,20 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_INTO_HPP
+#define TOML11_INTO_HPP
+#include "traits.hpp"
+
+namespace toml
+{
+
+template<typename T>
+struct into;
+// {
+//     static toml::value into_toml(const T& user_defined_type)
+//     {
+//         // User-defined conversions ...
+//     }
+// };
+
+} // toml
+#endif // TOML11_INTO_HPP
--- a/toml/literal.hpp
+++ b/toml/literal.hpp
@@ -0,0 +1,55 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_LITERAL_HPP
+#define TOML11_LITERAL_HPP
+#include "parser.hpp"
+
+namespace toml
+{
+inline namespace literals
+{
+inline namespace toml_literals
+{
+
+inline ::toml::value operator""_toml(const char* str, std::size_t len)
+{
+    ::toml::detail::location<std::vector<char>>
+        loc(/* filename = */ std::string("TOML literal encoded in a C++ code"),
+            /* contents = */ std::vector<char>(str, str + len));
+
+    // if there are some comments or empty lines, skip them.
+    using skip_line = ::toml::detail::repeat<toml::detail::sequence<
+            ::toml::detail::maybe<::toml::detail::lex_ws>,
+            ::toml::detail::maybe<::toml::detail::lex_comment>,
+            ::toml::detail::lex_newline
+        >, ::toml::detail::at_least<1>>;
+    skip_line::invoke(loc);
+
+    // if there are some whitespaces before a value, skip them.
+    using skip_ws = ::toml::detail::repeat<
+        ::toml::detail::lex_ws, ::toml::detail::at_least<1>>;
+    skip_ws::invoke(loc);
+
+    // literal may be a bare value. try them first.
+    if(auto data = ::toml::detail::parse_value(loc))
+    {
+        return data.unwrap();
+    }
+
+    // literal is a TOML file (i.e. multiline table).
+    if(auto data = ::toml::detail::parse_toml_file(loc))
+    {
+        loc.iter() = loc.begin(); // rollback to the top of the literal
+        return ::toml::value(std::move(data.unwrap()),
+                ::toml::detail::region<std::vector<char>>(std::move(loc)));
+    }
+    else // none of them.
+    {
+        throw ::toml::syntax_error(data.unwrap_err());
+    }
+}
+
+} // toml_literals
+} // literals
+} // toml
+#endif//TOML11_LITERAL_HPP
--- a/toml/parser.hpp
+++ b/toml/parser.hpp
@@ -250,11 +250,11 @@ std::string read_utf8_codepoint(const region<Container>& reg,
    {
        if(0xD800 <= codepoint && codepoint <= 0xDFFF)
        {
-            std::cerr << format_underline("[warning] "
+            throw syntax_error(format_underline("[error] "
                "toml::read_utf8_codepoint: codepoints in the range "
                "[0xD800, 0xDFFF] are not valid UTF-8.", {{
                    std::addressof(loc), "not a valid UTF-8 codepoint"
-                }}) << std::endl;
+                }}));
        }
        assert(codepoint < 0xD800 || 0xDFFF < codepoint);
        // 1110yyyy 10yxxxxx 10xxxxxx
@@ -262,15 +262,8 @@ std::string read_utf8_codepoint(const region<Container>& reg,
        character += static_cast<unsigned char>(0x80|(codepoint >> 6 & 0x3F));
        character += static_cast<unsigned char>(0x80|(codepoint      & 0x3F));
    }
-    else if(codepoint < 0x200000) // U+010000 ... U+1FFFFF
+    else if(codepoint < 0x110000) // U+010000 ... U+10FFFF
    {
-        if(0x10FFFF < codepoint) // out of Unicode region
-        {
-            std::cerr << format_underline("[error] "
-                "toml::read_utf8_codepoint: input codepoint is too large to "
-                "decode as a unicode character.", {{std::addressof(loc),
-                "should be in [0x00..0x10FFFF]"}}) << std::endl;
-        }
        // 11110yyy 10yyxxxx 10xxxxxx 10xxxxxx
        character += static_cast<unsigned char>(0xF0| codepoint >> 18);
        character += static_cast<unsigned char>(0x80|(codepoint >> 12 & 0x3F));
@@ -279,9 +272,9 @@ std::string read_utf8_codepoint(const region<Container>& reg,
    }
    else // out of UTF-8 region
    {
-        throw std::range_error(format_underline(concat_to_string("[error] "
-                "input codepoint (", str, ") is too large to encode as utf-8."),
-                {{std::addressof(reg), "should be in [0x00..0x10FFFF]"}}));
+        throw syntax_error(format_underline("[error] toml::read_utf8_codepoint:"
+            " input codepoint is too large.",
+            {{std::addressof(loc), "should be in [0x00..0x10FFFF]"}}));
    }
    return character;
 }
--- a/toml/region.hpp
+++ b/toml/region.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_REGION_H
-#define TOML11_REGION_H
+#ifndef TOML11_REGION_HPP
+#define TOML11_REGION_HPP
 #include "exception.hpp"
 #include <memory>
 #include <vector>
@@ -15,7 +15,7 @@ namespace toml
 namespace detail
 {

-// helper function to avoid std::string(0, 'c')
+// helper function to avoid std::string(0, 'c') or std::string(iter, iter)
 template<typename Iterator>
 std::string make_string(Iterator first, Iterator last)
 {
@@ -28,9 +28,7 @@ inline std::string make_string(std::size_t len, char c)
    return std::string(len, c);
 }

-// region in a container, normally in a file content.
-// shared_ptr points the resource that the iter points.
-// combinators returns this.
+// region_base is a base class of location and region that are defined below.
 // it will be used to generate better error messages.
 struct region_base
 {
@@ -48,16 +46,19 @@ 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;}
+    // length of the region
    virtual std::size_t size()     const noexcept {return 0;}
+    // number of characters in the line before the region
+    virtual std::size_t before()   const noexcept {return 0;}
+    // number of characters in the line after the region
    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.
-//
+// location represents a position in a container, which contains a file content.
 // it can be considered as a region that contains only one character.
+//
+// it contains pointer to the file content and iterator that points the current
+// location.
 template<typename Container>
 struct location final : public region_base
 {
@@ -131,6 +132,10 @@ struct location final : public region_base
    const_iterator iter_;
 };

+// region represents a range in a container, which contains a file content.
+//
+// it contains pointer to the file content and iterator that points the first
+// and last location.
 template<typename Container>
 struct region final : public region_base
 {
--- a/toml/result.hpp
+++ b/toml/result.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_RESULT_H
-#define TOML11_RESULT_H
+#ifndef TOML11_RESULT_HPP
+#define TOML11_RESULT_HPP
 #include "traits.hpp"
 #include <type_traits>
 #include <stdexcept>
--- a/toml/serializer.hpp
+++ b/toml/serializer.hpp
@@ -36,7 +36,7 @@ struct serializer
        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());
+        std::string token(buf.begin(), std::prev(buf.end()));
        if(token.back() == '.') // 1. => 1.0
        {
            token += '0';
@@ -483,15 +483,19 @@ struct serializer

 inline std::string
 format(const value& v, std::size_t w = 80,
-       int fprec = std::numeric_limits<toml::floating>::max_digits10)
+       int fprec = std::numeric_limits<toml::floating>::max_digits10,
+       bool force_inline = false)
 {
-    return visit(serializer(w, fprec, true), v);
+    // if value is a table, it is considered to be a root object.
+    // the root object can't be an inline table. so pass false. otherwise, true.
+    return visit(serializer(w, fprec, (!v.is_table()) || force_inline), v);
 }
 inline std::string
 format(const table& t, std::size_t w = 80,
-       int fprec = std::numeric_limits<toml::floating>::max_digits10)
+       int fprec = std::numeric_limits<toml::floating>::max_digits10,
+       bool force_inline = false)
 {
-    return serializer(w, fprec, true)(t);
+    return serializer(w, fprec, force_inline)(t);
 }

 template<typename charT, typename traits>
@@ -506,6 +510,18 @@ operator<<(std::basic_ostream<charT, traits>& os, const value& v)
    os << visit(serializer(w, fprec, false), v);
    return os;
 }
+template<typename charT, typename traits>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const table& 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 << serializer(w, fprec, false)(v);
+    return os;
+}

 } // toml
 #endif// TOML11_SERIALIZER_HPP
--- a/toml/string.hpp
+++ b/toml/string.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_STRING_H
-#define TOML11_STRING_H
+#ifndef TOML11_STRING_HPP
+#define TOML11_STRING_HPP
 #include <string>
 #include <cstdint>

--- a/toml/to_toml.hpp
+++ b/toml/to_toml.hpp
@@ -1,49 +0,0 @@
-//     Copyright Toru Niina 2017.
-// Distributed under the MIT License.
-#ifndef TOML11_TO_TOML
-#define TOML11_TO_TOML
-#include "value.hpp"
-
-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()));
-}
-
-} // toml
-#endif // TOML11_TO_TOML
--- a/toml/traits.hpp
+++ b/toml/traits.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_TRAITS
-#define TOML11_TRAITS
+#ifndef TOML11_TRAITS_HPP
+#define TOML11_TRAITS_HPP
 #include <type_traits>
 #include <utility>
 #include <chrono>
@@ -9,6 +9,9 @@

 namespace toml
 {
+
+class value; // forward decl
+
 namespace detail
 {

@@ -45,6 +48,22 @@ struct has_resize_method_impl
    template<typename T> static std::false_type check(...);
 };

+struct has_from_toml_method_impl
+{
+    template<typename T>
+    static std::true_type  check(
+        decltype(std::declval<T>().from_toml(std::declval<::toml::value>()))*);
+    template<typename T>
+    static std::false_type check(...);
+};
+struct has_into_toml_method_impl
+{
+    template<typename T>
+    static std::true_type  check(decltype(std::declval<T>().into_toml())*);
+    template<typename T>
+    static std::false_type check(...);
+};
+
 /// Intel C++ compiler can not use decltype in parent class declaration, here
 /// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076
 #ifdef __INTEL_COMPILER
@@ -62,6 +81,14 @@ struct has_mapped_type : decltype(has_mapped_type_impl::check<T>(nullptr)){};
 template<typename T>
 struct has_resize_method : decltype(has_resize_method_impl::check<T>(nullptr)){};

+
+template<typename T>
+struct has_from_toml_method
+: decltype(has_from_toml_method_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_into_toml_method
+: decltype(has_into_toml_method_impl::check<T>(nullptr)){};
+
 #ifdef __INTEL_COMPILER
 #undef decltype(...)
 #endif
@@ -142,6 +169,21 @@ using return_type_of_t = typename std::result_of<F(Args...)>::type;

 #endif

+// ---------------------------------------------------------------------------
+// is_string_literal
+//
+// to use this, pass `typename remove_reference<T>::type` to T.
+
+template<typename T>
+struct is_string_literal:
+disjunction<
+    std::is_same<const char*, T>,
+    conjunction<
+        std::is_array<T>,
+        std::is_same<const char, typename std::remove_extent<T>::type>
+        >
+    >{};
+
 }// detail
 }//toml
 #endif // TOML_TRAITS
--- a/toml/types.hpp
+++ b/toml/types.hpp
@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_TYPES_H
-#define TOML11_TYPES_H
+#ifndef TOML11_TYPES_HPP
+#define TOML11_TYPES_HPP
 #include "datetime.hpp"
 #include "string.hpp"
 #include "traits.hpp"
--- a/toml/utility.hpp
+++ b/toml/utility.hpp
@@ -1,18 +1,18 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_UTILITY
-#define TOML11_UTILITY
+#ifndef TOML11_UTILITY_HPP
+#define TOML11_UTILITY_HPP
 #include "traits.hpp"
 #include <utility>
 #include <memory>
 #include <sstream>

 #if __cplusplus >= 201402L
-#  define TOML11_MARK_AS_DEPRECATED [[deprecated]]
+#  define TOML11_MARK_AS_DEPRECATED(msg) [[deprecated(msg)]]
 #elif defined(__GNUC__)
-#  define TOML11_MARK_AS_DEPRECATED __attribute__((deprecated))
+#  define TOML11_MARK_AS_DEPRECATED(msg) __attribute__((deprecated(msg)))
 #elif defined(_MSC_VER)
-#  define TOML11_MARK_AS_DEPRECATED __declspec(deprecated)
+#  define TOML11_MARK_AS_DEPRECATED(msg) __declspec(deprecated(msg))
 #else
 #  define TOML11_MARK_AS_DEPRECATED
 #endif
--- a/toml/value.hpp
+++ b/toml/value.hpp
@@ -1,8 +1,9 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_VALUE
-#define TOML11_VALUE
+#ifndef TOML11_VALUE_HPP
+#define TOML11_VALUE_HPP
 #include "traits.hpp"
+#include "into.hpp"
 #include "utility.hpp"
 #include "exception.hpp"
 #include "storage.hpp"
@@ -473,7 +474,7 @@ class value
          region_info_(std::make_shared<region_base>(region_base{}))
    {
        array ary; ary.reserve(list.size());
-        for(auto& elem : list) {ary.emplace_back(std::move(elem));}
+        for(const auto& elem : list) {ary.emplace_back(elem);}
        assigner(this->array_, std::move(ary));
    }
    template<typename T, typename std::enable_if<detail::is_container<T>::value,
@@ -485,7 +486,7 @@ class value
        this->region_info_ = std::make_shared<region_base>(region_base{});

        array ary; ary.reserve(list.size());
-        for(auto& elem : list) {ary.emplace_back(std::move(elem));}
+        for(const auto& elem : list) {ary.emplace_back(elem);}
        assigner(this->array_, std::move(ary));
        return *this;
    }
@@ -533,10 +534,62 @@ class value
        return *this;
    }

+    // user-defined =========================================================
+
+    // convert using into_toml() method -------------------------------------
+
+    template<typename T, typename std::enable_if<detail::conjunction<
+        detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+        detail::has_into_toml_method<T> // but has `into_toml` method
+        >::value, std::nullptr_t>::type = nullptr>
+    value(const T& ud): value(ud.into_toml()) {}
+
+    template<typename T, typename std::enable_if<detail::conjunction<
+        detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+        detail::has_into_toml_method<T> // but has `into_toml` method
+        >::value, std::nullptr_t>::type = nullptr>
+    value& operator=(const T& ud)
+    {
+        *this = ud.into_toml();
+        return *this;
+    }
+
+    // convert using into<T> struct -----------------------------------------
+
+    template<typename T, typename std::enable_if<
+        detail::negation<detail::is_exact_toml_type<T>>::value,
+        std::nullptr_t>::type = nullptr,
+        std::size_t S = sizeof(::toml::into<T>)>
+    value(const T& ud): value(::toml::into<T>::into_toml(ud)) {}
+
+    template<typename T, typename std::enable_if<
+        detail::negation<detail::is_exact_toml_type<T>>::value,
+        std::nullptr_t>::type = nullptr,
+        std::size_t S = sizeof(::toml::into<T>)>
+    value& operator=(const T& ud)
+    {
+        *this = ::toml::into<T>::into_toml(ud);
+        return *this;
+    }
+
+    // type checking and casting ============================================
+
    template<typename T>
    bool is() const noexcept {return value_traits<T>::type_index == this->type_;}
    bool is(value_t t) const noexcept {return t == this->type_;}

+    bool is_uninitialized()   const noexcept {return this->is(value_t::Empty         );}
+    bool is_boolean()         const noexcept {return this->is(value_t::Boolean       );}
+    bool is_integer()         const noexcept {return this->is(value_t::Integer       );}
+    bool is_float()           const noexcept {return this->is(value_t::Float         );}
+    bool is_string()          const noexcept {return this->is(value_t::String        );}
+    bool is_offset_datetime() const noexcept {return this->is(value_t::OffsetDatetime);}
+    bool is_local_datetime()  const noexcept {return this->is(value_t::LocalDatetime );}
+    bool is_local_date()      const noexcept {return this->is(value_t::LocalDate     );}
+    bool is_local_time()      const noexcept {return this->is(value_t::LocalTime     );}
+    bool is_array()           const noexcept {return this->is(value_t::Array         );}
+    bool is_table()           const noexcept {return this->is(value_t::Table         );}
+
    value_t type() const {return type_;}

    template<value_t T>
@@ -794,38 +847,40 @@ inline bool operator>=(const toml::value& lhs, const toml::value& rhs)
    return !(lhs < rhs);
 }

-namespace detail
-{
-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));
-}
-
-template<typename ... Ts>
-std::string format_error_impl(const std::string& err_msg,
-        std::vector<std::pair<region_base const*, std::string>> val,
+inline std::string format_error(const std::string& err_msg,
        const toml::value& v, const std::string& comment,
-        Ts&& ... args)
+        std::vector<std::string> hints = {})
 {
-    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)...);
+    return detail::format_underline(err_msg,
+        std::vector<std::pair<detail::region_base const*, std::string>>{
+            {std::addressof(detail::get_region(v)), comment}
+        }, std::move(hints));
 }
-} // detail

-template<typename ... Ts>
-std::string format_error(const std::string& err_msg, Ts&& ... args)
+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,
+        std::vector<std::string> hints = {})
 {
-    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)...);
+    return detail::format_underline(err_msg,
+        std::vector<std::pair<detail::region_base const*, std::string>>{
+            {std::addressof(detail::get_region(v1)), comment1},
+            {std::addressof(detail::get_region(v2)), comment2}
+        }, std::move(hints));
+}
+
+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,
+        const toml::value& v3, const std::string& comment3,
+        std::vector<std::string> hints = {})
+{
+    return detail::format_underline(err_msg,
+        std::vector<std::pair<detail::region_base const*, std::string>>{
+            {std::addressof(detail::get_region(v1)), comment1},
+            {std::addressof(detail::get_region(v2)), comment2},
+            {std::addressof(detail::get_region(v3)), comment3}
+        }, std::move(hints));
 }

 template<typename Visitor>
@@ -877,7 +932,7 @@ visit(Visitor&& visitor, toml::value& v)
 }

 template<typename Visitor>
-detail::return_type_of_t<Visitor, toml::boolean&>
+detail::return_type_of_t<Visitor, toml::boolean&&>
 visit(Visitor&& visitor, toml::value&& v)
 {
    switch(v.type())
Author	SHA1	Message	Date
ToruNiina	c3cb22a789	chore: fix example of err msg by re-running sample	2019-03-21 18:12:35 +09:00
ToruNiina	5aebd6b562	fix: restore the back compat of format_error the following code was okay in the last release ``` toml::format_error("[test]", v, "test", {"hint1", "hint2"}) ``` but was not okay in the current master. This commit fixes this. cons: By this, the number of values to show is limited upto 3.	2019-03-20 20:46:22 +09:00
ToruNiina	4c13085b35	fix: add stream operator for toml::table	2019-03-20 19:30:08 +09:00
ToruNiina	8709e8a14e	chore: fix incorrect syntax highlight in README	2019-03-20 19:29:03 +09:00
ToruNiina	9eea46ec01	chore: fix typoes and broken links in README	2019-03-20 12:06:55 +09:00
ToruNiina	2e9f937c43	chore: update README	2019-03-20 11:53:03 +09:00
Toru Niina	65b10b6537	Merge pull request #46 from ToruNiina/toml-literal feat: add ""_toml literal	2019-03-20 10:12:56 +09:00
ToruNiina	b51a8d5966	fix: add missing include file in test code	2019-03-20 00:58:58 +09:00
Toru Niina	55e3d70869	Merge pull request #47 from ToruNiina/format-table `toml::format` and top-level table	2019-03-20 00:49:59 +09:00
ToruNiina	20ba57e389	fix: add missing const specifier to some of get()s	2019-03-20 00:37:13 +09:00
ToruNiina	39bc3c64fe	test: add test for ""_toml literals	2019-03-20 00:36:46 +09:00
ToruNiina	40ccf1d912	feat: add argument to control top-level inlinization	2019-03-19 23:25:26 +09:00
ToruNiina	982ae36428	feat: add ""_toml literal	2019-03-19 21:34:57 +09:00
ToruNiina	d6714ec450	feat: detect value type and format as a file in toml::format	2019-03-19 21:24:51 +09:00
ToruNiina	773c3816be	ci: remove needless confirmation on CI	2019-03-19 19:39:45 +09:00
Toru Niina	1b417ddc7a	Merge pull request #45 from ToruNiina/get_or fix `get_or` and add `find_or`	2019-03-19 01:41:21 +09:00
ToruNiina	7a0ecf977d	feat: add find_or(table, key, fallback) get_or(value, fallback) is still ok, but get_or(table, key, fallback) is now deprecated.	2019-03-18 17:44:03 +09:00
ToruNiina	aade704411	refactor: remove needless overload of get_or	2019-03-18 17:10:18 +09:00
ToruNiina	ca3f6102ef	fix: correctly resolve overloads of get_or	2019-03-18 16:44:36 +09:00
ToruNiina	4a58b629ce	feat: add a way to check arg is "string literal"	2019-03-18 16:31:12 +09:00
ToruNiina	3adba237b8	feat: enable to show message for deprecated()	2019-03-18 16:28:27 +09:00
Toru Niina	ccf03d9291	Merge pull request #44 from ToruNiina/test-link test: add test for multiple translation unit	2019-03-18 15:20:04 +09:00
Toru Niina	30ae90ebd5	Merge pull request #43 from ToruNiina/hotfix fix: incorrect move in constructor and return type deducing in toml::visit	2019-03-18 14:08:23 +09:00
ToruNiina	d5369c3429	test: add test for multiple translation unit	2019-03-18 12:39:58 +09:00
Toru Niina	48f2f0555d	Merge pull request #42 from ToruNiina/test-suite run toml-test suite	2019-03-18 12:33:48 +09:00
ToruNiina	f40fd12e25	refactor: add and rewrite comments	2019-03-18 11:09:12 +09:00
ToruNiina	65c2c3c238	fix: correctly deduce return value of visitor	2019-03-18 10:53:04 +09:00
ToruNiina	891a61a5e3	fix: do not move array element without checking	2019-03-18 02:05:55 +09:00
ToruNiina	1e6f30f6fa	chore: update README.md	2019-03-18 01:50:23 +09:00
ToruNiina	02346a3126	Merge branch 'master' into test-suite	2019-03-18 01:40:17 +09:00
Toru Niina	1908f18e95	Merge pull request #41 from ToruNiina/hotfix fix: simplify and correct the format of timezone	2019-03-18 01:39:11 +09:00
ToruNiina	3bfa7f09ba	test: use the test suite in the effective way add tests/check_toml_test.cpp to compare json object	2019-03-18 01:36:43 +09:00
ToruNiina	243f43fafd	Merge branch 'master' into hotfix	2019-03-17 21:16:37 +09:00
ToruNiina	66e27a94b6	fix: simplify and correct the format of timezone	2019-03-17 21:14:17 +09:00
ToruNiina	227688ec63	ci: make result clearer a bit	2019-03-17 19:36:23 +09:00
ToruNiina	e761a503c0	ci: fix silly mistake in circleci script	2019-03-17 19:27:58 +09:00
ToruNiina	209ad79a8f	ci: fix config file of circleci	2019-03-17 19:26:22 +09:00
ToruNiina	cdf209d7f6	ci: show the status on CI	2019-03-17 19:23:52 +09:00
ToruNiina	77ab391885	ci: fix name of directory and add test script	2019-03-17 19:20:24 +09:00
ToruNiina	6628fe5ace	test: add language agnostic toml-test	2019-03-17 19:12:13 +09:00
Toru Niina	f3e3000d45	Merge pull request #40 from ToruNiina/remove-to-toml refactor: remove to_toml and related tests	2019-03-17 13:12:30 +09:00
Toru Niina	f7380c6e32	Merge pull request #39 from ToruNiina/throw-incorrect-unicode Throw syntax_error when parser encounter an incorrect utf-8 codepoint	2019-03-17 13:12:16 +09:00
Toru Niina	d86870e038	Merge pull request #38 from ToruNiina/get-any-type extended conversions	2019-03-17 13:11:59 +09:00
Toru Niina	0908806915	Merge pull request #33 from ToruNiina/is-something add `is_boolean` and other stuffs like that	2019-03-16 23:55:01 +09:00
ToruNiina	d17c192681	refactor: remove to_toml and related tests	2019-03-16 17:05:58 +09:00
ToruNiina	cad8f51256	doc: add explanation of conversions to README	2019-03-16 16:56:37 +09:00
ToruNiina	43014c6619	fix: remove redefined default template argument	2019-03-16 16:24:10 +09:00
ToruNiina	30a41aa710	fix: use older style in BOOST_TEST	2019-03-16 16:15:01 +09:00
ToruNiina	04bfeba3f2	merge branch master into get-any-type	2019-03-16 15:58:18 +09:00
ToruNiina	190636b791	fix: support getting a container of external types	2019-03-16 15:52:22 +09:00
ToruNiina	31e450f9af	test: add test for `from/into` based conversions	2019-03-16 15:46:21 +09:00
ToruNiina	b1b72a94a8	feat: support conversion with external types	2019-03-16 14:44:04 +09:00
ToruNiina	6929bcdf78	feat: add from<T> and into<T>	2019-03-16 14:27:05 +09:00
ToruNiina	fd063af7ce	refactor: make include guard style uniform	2019-03-16 14:19:47 +09:00
ToruNiina	df6dcbc4ed	feat: check a class has from/into_toml member fn to support better serialization	2019-03-16 14:16:31 +09:00
ToruNiina	9b8db6a225	fix: remove extraneous null character after float the bug was introduced by snprintf	2019-03-15 19:30:36 +09:00
ToruNiina	76863cb27f	refactor: simplify branches about utf8 codepoint	2019-03-15 17:48:47 +09:00
ToruNiina	514df99e40	feat: consider invalid UTF-8 as syntax_error the following codepoints are considered to be a syntax_error - [0xD800, 0xDFFF] - larger than 0x10FFFF	2019-03-15 17:39:31 +09:00
ToruNiina	055353a460	chore: merge branch 'master' into is-something	2019-03-15 17:25:17 +09:00
ToruNiina	c4c416e8b2	doc: add is_* function to README	2019-03-12 22:18:25 +09:00
ToruNiina	6693ec78f4	test: add test for toml::value::is_something()	2019-03-12 20:44:27 +09:00
ToruNiina	dc112bd6c1	feat: add is_[boolean\|integer\|...]() member func it is an alias to is<toml::value_t::[Boolean\|Integer\|...]>	2019-03-12 20:43:07 +09:00