chore: update version info in CMake

Merge branch 'colorize-err-msg'
doc: put screenshot to colorize-error-message
2025-12-16 03:08:52 +08:00 · 2019-12-13 20:25:52 +09:00 · 2019-12-13 20:23:27 +09:00 · 2019-12-13 17:28:43 +09:00 · 2019-12-13 16:47:33 +09:00 · 2019-12-12 21:31:21 +09:00
32 changed files with 2233 additions and 563 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -12,7 +12,7 @@ jobs:
          command: |
              g++ --version
              cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check_toml_test.cpp -o check_toml_test
+              g++ -std=c++11 -O2 -Wall -Wextra -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -I../ check_toml_test.cpp -o check_toml_test
              go get github.com/BurntSushi/toml-test
              $GOPATH/bin/toml-test ./check_toml_test
  test_serialization:
@@ -24,7 +24,7 @@ jobs:
          command: |
              g++ --version
              cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -I../ check_serialization.cpp -o check_serialization
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -I../ check_serialization.cpp -o check_serialization
              git clone https://github.com/BurntSushi/toml-test.git
              cp check_serialization toml-test/tests/valid
              cd toml-test/tests/valid
@@ -47,7 +47,7 @@ jobs:
          command: |
              g++ --version
              cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -I../ check.cpp -o check
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -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
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,11 +5,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-5" CXX_STANDARD=11
+    env: COMPILER="g++-5" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-5
@@ -17,11 +17,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-6" CXX_STANDARD=11
+    env: COMPILER="g++-6" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-6
@@ -29,11 +29,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-7" CXX_STANDARD=11
+    env: COMPILER="g++-7" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-7
@@ -41,11 +41,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=11
+    env: COMPILER="g++-8" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
@@ -53,11 +53,35 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=17
+    env: COMPILER="g++-8" CXX_STANDARD=11 TOML_HEAD=ON
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        packages:
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=OFF
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        packages:
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=ON
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
@@ -65,27 +89,27 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-3.7" CXX_STANDARD=11
+    env: COMPILER="clang++-3.9" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-precise-3.7
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-3.9
        packages:
        - g++-8
-        - clang-3.7
+        - clang-3.9
        - boost1.70
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-4.0" CXX_STANDARD=11
+    env: COMPILER="clang++-4.0" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
        - llvm-toolchain-trusty-4.0
-        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
        - clang-4.0
@@ -93,13 +117,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-5.0" CXX_STANDARD=11
+    env: COMPILER="clang++-5.0" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-5.0
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-5.0
        packages:
        - g++-8
        - clang-5.0
@@ -107,13 +131,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-6.0" CXX_STANDARD=11
+    env: COMPILER="clang++-6.0" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-6.0
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-6.0
        packages:
        - g++-8
        - clang-6.0
@@ -121,13 +145,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-7" CXX_STANDARD=11
+    env: COMPILER="clang++-7" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-7
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-7
        packages:
        - g++-8
        - clang-7
@@ -135,13 +159,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=11
+    env: COMPILER="clang++-8" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
        packages:
        - g++-8
        - clang-8
@@ -149,13 +173,41 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=17
+    env: COMPILER="clang++-8" CXX_STANDARD=11 TOML_HEAD=ON
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
+        packages:
+        - g++-8
+        - clang-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=OFF
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
+        packages:
+        - clang-8
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=ON
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
        packages:
        - clang-8
        - g++-8
@@ -164,6 +216,15 @@ matrix:
    language: cpp
    compiler: clang
    env: CXX_STANDARD=11
+    cache:
+      directories:
+        - $HOME/Library/Caches/Homebrew
+    addons:
+      homebrew:
+        update: true
+        packages:
+        - cmake
+        - boost

 script:
 - |
@@ -172,13 +233,18 @@ script:
    travis_retry wget "https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.5-Linux-x86_64.tar.gz"
    tar xf cmake-3.14.5-Linux-x86_64.tar.gz -C cmake --strip-components=1
    export PATH=${TRAVIS_BUILD_DIR}/cmake/bin:${PATH}
-  else
-    brew upgrade cmake boost
  fi
 - cmake --version
 - mkdir build
 - cd build
 - git clone https://github.com/toml-lang/toml.git
- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD ..
+- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD -DTOML11_USE_UNRELEASED_TOML_FEATURES=${TOML_HEAD} ..
 - make
 - ctest --output-on-failure
+
+# https://stackoverflow.com/a/53331571
+before_cache:
+- |
+  if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+    brew cleanup
+  fi
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,10 +4,10 @@ enable_testing()
 project(toml11)

 set(toml11_VERSION_MAYOR  3)
-set(toml11_VERSION_MINOR  0)
+set(toml11_VERSION_MINOR  2)
 set(toml11_VERSION_PATCH  0)
 set(toml11_VERSION
-  "${toml11_VERSION_MAYOR}.${toml11_VERSION_MINOR}.${toml11_VERSION_PATCH}-beta"
+  "${toml11_VERSION_MAYOR}.${toml11_VERSION_MINOR}.${toml11_VERSION_PATCH}"
 )

 option(toml11_BUILD_TEST "Build toml tests" ON)
--- a/README.md
+++ b/README.md
@@ -47,8 +47,9 @@ int main()
 - [Decoding a toml file](#decoding-a-toml-file)
  - [In the case of syntax error](#in-the-case-of-syntax-error)
  - [Invalid UTF-8 Codepoints](#invalid-utf-8-codepoints)
- [Finding a toml value](#finding-a-toml-value-from-a-table)
-  - [In the case of type error](#in-the-case-of-type-error)
+- [Finding a toml value](#finding-a-toml-value)
+  - [Finding a value in a table](#finding-a-value-in-a-table)
+  - [In case of error](#in-case-of-error)
  - [Dotted keys](#dotted-keys)
 - [Casting a toml value](#casting-a-toml-value)
 - [Checking value type](#checking-value-type)
@@ -67,8 +68,12 @@ int main()
 - [TOML literal](#toml-literal)
 - [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types)
 - [Formatting user-defined error messages](#formatting-user-defined-error-messages)
+- [Obtaining location information](#obtaining-location-information)
+- [Exceptions](#exceptions)
+- [Colorize Error Messages](#colorize-error-messages)
 - [Serializing TOML data](#serializing-toml-data)
 - [Underlying types](#underlying-types)
+- [Unreleased TOML features](#unreleased-toml-features)
 - [Breaking Changes from v2](#breaking-changes-from-v2)
 - [Running Tests](#running-tests)
 - [Contributors](#contributors)
@@ -101,7 +106,7 @@ to pass a filename to the `toml::parse` function.

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

 If it encounters an error while opening a file, it will throw `std::runtime_error`.
@@ -185,7 +190,7 @@ representing unicode character is not a valid UTF-8 codepoint.
   |                              ^--------- should be in [0x00..0x10FFFF]
 ```

-## Finding a toml value from a table
+## Finding a toml value

 After parsing successfully, you can obtain the values from the result of
 `toml::parse` using `toml::find` function.
@@ -196,8 +201,6 @@ answer  = 42
 pi      = 3.14
 numbers = [1,2,3]
 time    = 1979-05-27T07:32:00Z
-[tab]
-key = "value"
 ```

 ``` cpp
@@ -206,23 +209,16 @@ const auto answer    = toml::find<std::int64_t    >(data, "answer");
 const auto pi        = toml::find<double          >(data, "pi");
 const auto numbers   = toml::find<std::vector<int>>(data, "numbers");
 const auto timepoint = toml::find<std::chrono::system_clock::time_point>(data, "time");
-const auto tab       = toml::find<toml::table>(data, "tab");
-const auto key       = toml::find<std::string>(tab,  "key");
 ```

-If the value does not exist, `toml::find` throws an error with the location of
-the table.
+By default, `toml::find` returns a `toml::value`.

-```console
-terminate called after throwing an instance of 'std::out_of_range'
-  what():  [error] key "answer" not found
- --> example.toml
- 6 | [tab]
-   | ~~~~~ in this table
+```cpp
+const toml::value& answer = toml::find(data, "answer");
 ```

 When you pass an exact TOML type that does not require type conversion,
-`toml::get` returns a reference without copying the value.
+`toml::find` returns a reference without copying the value.

 ```cpp
 const auto  data   = toml::parse("sample.toml");
@@ -232,12 +228,6 @@ const auto& answer = toml::find<toml::integer>(data, "answer");
 If the specified type requires conversion, you can't take a reference to the value.
 See also [underlying types](#underlying-types).

-By default, `toml::find` returns a `toml::value`.
-
-```cpp
-const toml::value& answer = toml::find(data, "answer");
-```
-
 **NOTE**: For some technical reason, automatic conversion between `integer` and
 `floating` is not supported. If you want to get a floating value even if a value
 has integer value, you need to convert it manually after obtaining a value,
@@ -250,23 +240,59 @@ double x = vx.is_floating() ? vx.as_floating(std::nothrow) :
                                                 // floating nor integer.
 ```

----
+### Finding a value in a table

-`toml::find` accepts arbitrary number of keys to find a value buried in a
-deep recursion of tables.
+There are several way to get a value defined in a table.
+First, you can get a table as a normal value and find a value from the table.

-```cpp
-// # expecting the following example.toml
-// answer.to.the.ultimate.question = 42
-// # is equivalent to {"answer": {"to":{"the":{"ultimate:{"question":42}}}}}
-
-const toml::table data = toml::parse("example.toml");
-const int a = toml::find<int>(data, "answer", "to", "the", "ultimate", "question");
+```toml
+[fruit]
+name = "apple"
+[fruit.physical]
+color = "red"
+shape = "round"
 ```

-Of course, alternatively, you can call `toml::find` as many as you need.
+``` cpp
+const auto  data  = toml::parse("fruit.toml");
+const auto& fruit = toml::find(data, "fruit");
+const auto  name  = toml::find<std::string>(fruit, "apple");

-### In the case of type error
+const auto& physical = toml::find(fruit, "physical");
+const auto  color    = toml::find<std::string>(fruit, "color");
+const auto  shape    = toml::find<std::string>(fruit, "shape");
+```
+
+Here, variable `fruit` is a `toml::value` and can be used as the first argument
+of `toml::find`.
+
+Second, you can pass as many arguments as the number of subtables to `toml::find`.
+
+```cpp
+const auto data  = toml::parse("fruit.toml");
+const auto color = toml::find<std::string>(data, "fruit", "physical", "color");
+const auto shape = toml::find<std::string>(data, "fruit", "physical", "shape");
+```
+
+### In case of error
+
+If the value does not exist, `toml::find` throws an error with the location of
+the table.
+
+```console
+terminate called after throwing an instance of 'std::out_of_range'
+  what():  [error] key "answer" not found
+ --> example.toml
+ 6 | [tab]
+   | ~~~~~ in this table
+```
+
+**Note**: It is recommended to find a table as `toml::value` because it has much information
+compared to `toml::table`, which is an alias of
+`std::unordered_map<std::string, toml::value>`. Since `toml::table` does not have
+any information about toml file, such as where the table was defined in the file.
+
+----

 If the specified type differs from the actual value contained, it throws
 `toml::type_error` that inherits `std::exception`.
@@ -309,14 +335,15 @@ shape = "round"
 You can get both of the above tables with the same c++ code.

 ```cpp
-const auto physical = toml::find<toml::table>(data, "physical");
+const auto physical = toml::find(data, "physical");
 const auto color    = toml::find<std::string>(physical, "color");
 ```

 The following code does not work for the above toml file.

 ```cpp
-const auto color = toml::find<std::string>(data, "physical.color"); // does not work
+// XXX this does not work!
+const auto color = toml::find<std::string>(data, "physical.color");
 ```

 The above code works with the following toml file.
@@ -327,6 +354,7 @@ The above code works with the following toml file.
 # NOT {"physical": {"color": "orange"}}.
 ```

+
 ## Casting a toml value

 ### `toml::get`
@@ -348,18 +376,22 @@ contain one of the following types.
  - It depends. See [customizing containers](#customizing-containers) for detail.

 To get a value inside, you can use `toml::get<T>()`. The usage is the same as
-`toml::find<T>` (actually, `toml::find` internally uses `toml::get`).
+`toml::find<T>` (actually, `toml::find` internally uses `toml::get` after casting
+a value to `toml::table`).

 ``` cpp
 const toml::value  data    = toml::parse("sample.toml");
-const toml::value  answer_ = toml::get<toml::table >(data).at("answer")
+const toml::value  answer_ = toml::get<toml::table >(data).at("answer");
 const std::int64_t answer  = toml::get<std::int64_t>(answer_);
 ```

 When you pass an exact TOML type that does not require type conversion,
-`toml::get` returns a reference through which you can modify the content.
+`toml::get` returns a reference through which you can modify the content
+(if the `toml::value` is `const`, it returns `const` reference).

 ```cpp
+toml::value   data    = toml::parse("sample.toml");
+toml::value   answer_ = toml::get<toml::table >(data).at("answer");
 toml::integer& answer = toml::get<toml::integer>(answer_);
 answer = 6 * 9; // write to data.answer. now `answer_` contains 54.
 ```
@@ -426,7 +458,59 @@ class value {
 } // toml
 ```

+### `at()`

+You can access to the element of a table and an array by `toml::basic_value::at`.
+
+```cpp
+const toml::value v{1,2,3,4,5};
+std::cout << v.at(2).as_integer() << std::endl; // 3
+
+const toml::value v{{"foo", 42}, {"bar", 3.14}};
+std::cout << v.at("foo").as_integer() << std::endl; // 42
+```
+
+If an invalid key (integer for a table, string for an array), it throws
+`toml::type_error` for the conversion. If the provided key is out-of-range,
+it throws `std::out_of_range`.
+
+Note that, although `std::string` has `at()` member function, `toml::value::at`
+throws if the contained type is a string. Because `std::string` does not
+contain `toml::value`.
+
+### `operator[]`
+
+You can also access to the element of a table and an array by
+`toml::basic_value::operator[]`.
+
+```cpp
+const toml::value v{1,2,3,4,5};
+std::cout << v[2].as_integer() << std::endl; // 3
+
+const toml::value v{{"foo", 42}, {"bar", 3.14}};
+std::cout << v["foo"].as_integer() << std::endl; // 42
+```
+
+When you access to a `toml::value` that is not initialized yet via
+`operator[](const std::string&)`, the `toml::value` will be a table,
+just like the `std::map`.
+
+```cpp
+toml::value v; // not initialized as a table.
+v["foo"] = 42; // OK. `v` will be a table.
+```
+
+Contrary, if you access to a `toml::value` that contains an array via `operator[]`,
+it does not check anything. It converts `toml::value` without type check and then
+access to the n-th element without boundary check, just like the `std::vector::operator[]`.
+
+```cpp
+toml::value v; // not initialized as an array
+v[2] = 42;     // error! UB
+```
+
+Please make sure that the `toml::value` has an array inside when you access to
+its element via `operator[]`.

 ## Checking value type

@@ -650,6 +734,7 @@ 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
+# sample.toml
 date = 2018-12-23
 time = 12:30:00
 l_dt = 2018-12-23T12:30:00
@@ -666,8 +751,12 @@ 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
 ```

-toml11 defines its own datetime classes.
-You can see the definitions in [toml/datetime.hpp](toml/datetime.hpp).
+`local_date` and `local_datetime` are assumed to be in the local timezone when
+they are converted into `time_point`. On the other hand, `offset_datetime` only
+uses the offset part of the data and it does not take local timezone into account.
+
+To contain datetime data, toml11 defines its own datetime types.
+For more detail, you can see the definitions in [toml/datetime.hpp](toml/datetime.hpp).

 ## Getting with a fallback

@@ -1049,7 +1138,7 @@ namespace toml
 template<>
 struct from<ext::foo>
 {
-    ext::foo from_toml(const value& v)
+    static ext::foo from_toml(const value& v)
    {
        ext::foo f;
        f.a = find<int        >(v, "a");
@@ -1089,7 +1178,7 @@ template<>
 struct from<ext::foo>
 {
    template<typename C, template<typename ...> class M, template<typename ...> class A>
-    ext::foo from_toml(const basic_value<C, M, A>& v)
+    static ext::foo from_toml(const basic_value<C, M, A>& v)
    {
        ext::foo f;
        f.a = find<int        >(v, "a");
@@ -1145,7 +1234,7 @@ namespace toml
 template<>
 struct into<ext::foo>
 {
-    toml::table into_toml(const ext::foo& f)
+    static toml::table into_toml(const ext::foo& f)
    {
        return toml::table{{"a", f.a}, {"b", f.b}, {"c", f.c}};
    }
@@ -1212,7 +1301,28 @@ you will get an error message like this.
   |       ~~ maximum number here
 ```

-### Obtaining location information
+You can print hints at the end of the message.
+
+```cpp
+std::vector<std::string> hints;
+hints.push_back("positive number means n >= 0.");
+hints.push_back("negative number is not positive.");
+std::cerr << toml::format_error("[error] value should be positive",
+                                data.at("num"), "positive number required", hints)
+          << std::endl;
+```
+
+```console
+[error] value should be positive
+ --> example.toml
+ 2 | num = 42
+   |       ~~ positive number required
+   |
+Hint: positive number means n >= 0.
+Hint: negative number is not positive.
+```
+
+## Obtaining location information

 You can also format error messages in your own way by using `source_location`.

@@ -1237,6 +1347,92 @@ const toml::value           v   = /*...*/;
 const toml::source_location loc = v.location();
 ```

+## Exceptions
+
+All the exceptions thrown by toml11 inherits `toml::exception` that inherits
+`std::exception`.
+
+```cpp
+namespace toml {
+struct exception      : public std::exception  {/**/};
+struct syntax_error   : public toml::exception {/**/};
+struct type_error     : public toml::exception {/**/};
+struct internal_error : public toml::exception {/**/};
+} // toml
+```
+
+`toml::exception` has `toml::exception::location()` member function that returns
+`toml::source_location`, in addition to `what()`.
+
+```cpp
+namespace toml {
+struct exception : public std::exception
+{
+    // ...
+    source_location const& location() const noexcept;
+};
+} // toml
+```
+
+It represents where the error occurs.
+
+## Colorize Error Messages
+
+By defining `TOML11_COLORIZE_ERROR_MESSAGE`, the error messages from
+`toml::parse` and `toml::find|get` will be colorized. By default, this feature
+is turned off.
+
+With the following toml file taken from `toml-lang/toml/tests/hard_example.toml`,
+
+```toml
+[error]
+array = [
+         "This might most likely happen in multiline arrays",
+         Like here,
+         "or here,
+         and here"
+        ]     End of array comment, forgot the #
+```
+
+the error message would be like this.
+
+![error-message-1](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-1.png)
+
+With the following,
+
+```toml
+[error]
+# array = [
+#          "This might most likely happen in multiline arrays",
+#          Like here,
+#          "or here,
+#          and here"
+#         ]     End of array comment, forgot the #
+number = 3.14  pi <--again forgot the #
+```
+
+the error message would be like this.
+
+![error-message-2](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-2.png)
+
+The message would be messy when it is written to a file, not a terminal because
+it uses [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code).
+
+Without `TOML11_COLORIZE_ERROR_MESSAGE`, you can still colorize user-defined
+error message by passing `true` to the `toml::format_error` function.
+If you define `TOML11_COLORIZE_ERROR_MESSAGE`, the value is `true` by default.
+If not, the defalut value would be `false`.
+
+```cpp
+std::cerr << toml::format_error("[error] value should be positive",
+                                data.at("num"), "positive number required",
+                                hints, /*colorize = */ true) << std::endl;
+```
+
+Note: It colorize `[error]` in red. That means that it detects `[error]` prefix
+at the front of the error message. If there is no `[error]` prefix,
+`format_error` adds it to the error message.
+
 ## Serializing TOML data

 toml11 enables you to serialize data into toml format.
@@ -1369,7 +1565,83 @@ This feature is introduced to make it easy to write a custom serializer.
 Because `std::chrono::system_clock::time_point` is a __time point__,
 not capable of representing a Local Time independent from a specific day.

-It is recommended to get `datetime`s as `std::chrono` classes through `toml::get`.
+## Unreleased TOML features
+
+There are some unreleased features in toml-lang/toml:master.
+Currently, the following features are available after defining
+`TOML11_USE_UNRELEASED_TOML_FEATURES` macro flag.
+
+To use those features, `#define` `TOML11_USE_UNRELEASED_TOML_FEATURES` before
+including `toml.hpp` or pass `-DTOML11_USE_UNRELEASED_TOML_FEATURES` to your
+compiler.
+
+- Leading zeroes in exponent parts of floats are permitted.
+  - e.g. `1.0e+01`, `5e+05`
+  - [toml-lang/toml/PR/656](https://github.com/toml-lang/toml/pull/656)
+- Allow raw tab characters in basic strings and multi-line basic strings.
+  - [toml-lang/toml/PR/627](https://github.com/toml-lang/toml/pull/627)
+- Allow heterogeneous arrays
+  - [toml-lang/toml/PR/676](https://github.com/toml-lang/toml/pull/676)
+
+### Note about heterogeneous arrays
+
+Although `toml::parse` allows heterogeneous arrays, constructor of `toml::value`
+does not.
+
+```cpp
+// this won't be compiled
+toml::value v{
+    "foo", 3.14, 42, {1,2,3,4,5}, {{"key", "value"}}
+}
+```
+
+There is a workaround for this issue. By explicitly converting values into
+`toml::value`, you can initialize `toml::value` with a heterogeneous array.
+
+```cpp
+// OK!
+toml::value v{
+    toml::value("foo"), toml::value(3.14), toml::value(42),
+    toml::value{1,2,3,4,5}, toml::value{{"key", "value"}}
+}
+```
+
+The reason why the first example is not allowed is the following.
+Let's assume that you are initializing a `toml::value` with a table.
+
+```cpp
+                    // # expecting TOML table.
+toml::value v{      // [v]
+    {"answer", 42}, // answer = 42
+    {"pi",   3.14}, // pi = 3.14
+    {"foo", "bar"}  // foo = "bar"
+};
+```
+
+This is indistinguishable from a (heterogeneous) TOML array definition.
+
+```toml
+v = [
+    ["answer", 42],
+    ["pi",   3.14],
+    ["foo", "bar"],
+]
+```
+
+This means that the above C++ code makes constructor's overload resolution
+ambiguous. So a constructor that allows both "table as an initializer-list" and
+"heterogeneous array as an initializer-list" cannot be implemented.
+
+Thus, although it is painful, you need to explicitly cast values into
+`toml::value` when you initialize heterogeneous array in C++ code.
+
+```cpp
+// You need to do this when you want to initialize hetero array.
+toml::value v{
+    toml::value("foo"), toml::value(3.14), toml::value(42),
+    toml::value{1,2,3,4,5}, toml::value{{"key", "value"}}
+}
+```

 ## Breaking Changes from v2

@@ -1392,8 +1664,9 @@ Between v2 and v3, those interfaces are rearranged.
  - See [Casting a toml::value](#casting-a-tomlvalue) and [Checking value type](#checking-value-type) for detail.
 - An overload of `toml::find` for `toml::table` has been dropped. Use `toml::value` version instead.
  - Because type conversion between a table and a value causes ambiguity while overload resolution
+  - Since `toml::parse` now returns a `toml::value`, this feature becomes less important.
  - Also because `toml::table` is a normal STL container, implementing utility function is easy.
-  - See [Finding a toml::value](#finding-a-tomlvalue) for detail.
+  - See [Finding a toml::value](#finding-a-toml-value) for detail.
 - An overload of `operator<<` and `toml::format` for `toml::table`s are dropped.
  - Use `toml::value` instead.
  - See [Serializing TOML data](#serializing-toml-data) for detail.
@@ -1439,6 +1712,13 @@ I appreciate the help of the contributors who introduced the great feature to th
  - Fixed warnings while type conversion
 - @KerstinKeller
  - Added installation script to CMake
+- J.C. Moyer (@jcmoyer)
+  - Fixed an example code in the documentation
+- Jt Freeman (@blockparty-sh)
+  - Fixed feature test macro around `localtime_s`
+  - Suppress warnings in Debug mode
+- OGAWA Kenichi (@kenichiice)
+  - Suppress warnings on intel compiler

 ## Licensing terms

--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -50,6 +50,14 @@ if(COMPILER_SUPPORTS_WPEDANTIC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wpedantic")
 endif()

+option(TOML11_USE_UNRELEASED_TOML_FEATURES
+    "use features in toml-lang/toml master while testing" OFF)
+
+if(TOML11_USE_UNRELEASED_TOML_FEATURES)
+    message(STATUS "adding TOML11_USE_UNRELEASED_TOML_FEATURES flag")
+    add_definitions("-DTOML11_USE_UNRELEASED_TOML_FEATURES")
+endif()
+
 # Disable some MSVC warnings
 if(MSVC)
    # conversion from 'double' to 'unsigned int', possible loss of data
--- a/tests/test_error_detection.cpp
+++ b/tests/test_error_detection.cpp
@@ -80,10 +80,14 @@ BOOST_AUTO_TEST_CASE(test_detect_conflicting_value)

 BOOST_AUTO_TEST_CASE(test_detect_inhomogeneous_array)
 {
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("heterogeneous array will be allowed in the next release");
+#else
    std::istringstream stream(std::string(
            "a = [1, 1.0]\n"
            ));
    BOOST_CHECK_THROW(toml::parse(stream), toml::syntax_error);
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_detect_appending_array_of_table)
--- a/tests/test_extended_conversions.cpp
+++ b/tests/test_extended_conversions.cpp
@@ -33,6 +33,17 @@ struct bar
        return toml::table{{"a", this->a}, {"b", this->b}};
    }
 };
+
+struct baz
+{
+    int a;
+    std::string b;
+};
+struct qux
+{
+    int a;
+    std::string b;
+};
 } // extlib

 namespace toml
@@ -54,6 +65,24 @@ struct into<extlib::foo>
        return toml::table{{"a", f.a}, {"b", f.b}};
    }
 };
+
+template<>
+struct from<extlib::baz>
+{
+    static extlib::baz from_toml(const toml::value& v)
+    {
+        return extlib::baz{toml::find<int>(v, "a"), toml::find<std::string>(v, "b")};
+    }
+};
+
+template<>
+struct into<extlib::qux>
+{
+    static toml::table into_toml(const extlib::qux& f)
+    {
+        return toml::table{{"a", f.a}, {"b", f.b}};
+    }
+};
 } // toml

 // ---------------------------------------------------------------------------
@@ -83,6 +112,16 @@ struct bar
        return toml::table{{"a", this->a}, {"b", this->b}};
    }
 };
+struct baz
+{
+    int a;
+    std::string b;
+};
+struct qux
+{
+    int a;
+    std::string b;
+};
 } // extlib2

 namespace toml
@@ -105,6 +144,28 @@ struct into<extlib2::foo>
        return toml::table{{"a", f.a}, {"b", f.b}};
    }
 };
+
+template<>
+struct from<extlib2::baz>
+{
+    template<typename C, template<typename ...> class M, template<typename ...> class A>
+    static extlib2::baz from_toml(const toml::basic_value<C, M, A>& v)
+    {
+        return extlib2::baz{toml::find<int>(v, "a"), toml::find<std::string>(v, "b")};
+    }
+};
+
+template<>
+struct into<extlib2::qux>
+{
+    static toml::basic_value<toml::preserve_comments, std::map>
+    into_toml(const extlib2::qux& f)
+    {
+        return toml::basic_value<toml::preserve_comments, std::map>{
+            {"a", f.a}, {"b", f.b}
+        };
+    }
+};
 } // toml

 // ---------------------------------------------------------------------------
@@ -188,6 +249,41 @@ BOOST_AUTO_TEST_CASE(test_conversion_by_specialization)
    }
 }

+BOOST_AUTO_TEST_CASE(test_conversion_one_way)
+{
+    {
+        const toml::value v{{"a", 42}, {"b", "baz"}};
+
+        const auto baz = toml::get<extlib::baz>(v);
+        BOOST_TEST(baz.a == 42);
+        BOOST_TEST(baz.b == "baz");
+    }
+    {
+        const extlib::qux q{42, "qux"};
+        const toml::value v(q);
+
+        BOOST_TEST(toml::find<int>(v, "a")         == 42);
+        BOOST_TEST(toml::find<std::string>(v, "b") == "qux");
+    }
+
+    {
+        const toml::basic_value<toml::discard_comments, std::map> v{
+            {"a", 42}, {"b", "baz"}
+        };
+
+        const auto baz = toml::get<extlib2::baz>(v);
+        BOOST_TEST(baz.a == 42);
+        BOOST_TEST(baz.b == "baz");
+    }
+    {
+        const extlib::qux q{42, "qux"};
+        const toml::basic_value<toml::preserve_comments, std::map> v(q);
+
+        BOOST_TEST(toml::find<int>(v, "a")         == 42);
+        BOOST_TEST(toml::find<std::string>(v, "b") == "qux");
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_recursive_conversion)
 {
    {
--- a/tests/test_find.cpp
+++ b/tests/test_find.cpp
@@ -27,6 +27,32 @@ using test_value_types = std::tuple<

 BOOST_AUTO_TEST_CASE(test_find_throws)
 {
+    // -----------------------------------------------------------------------
+    // const-reference version
+    {
+        // value is not a table
+        const toml::value v(true);
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not the expected type
+        const toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not found
+        const toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::integer>(v, "different_key"),
+                          std::out_of_range);
+    }
+    {
+        // the positive control.
+        const toml::value v{{"key", 42}};
+        BOOST_TEST(42 == toml::find<int>(v, "key"));
+    }
+
+    // -----------------------------------------------------------------------
+    // reference version
    {
        // value is not a table
        toml::value v(true);
@@ -48,6 +74,31 @@ BOOST_AUTO_TEST_CASE(test_find_throws)
        toml::value v{{"key", 42}};
        BOOST_TEST(42 == toml::find<int>(v, "key"));
    }
+
+    // -----------------------------------------------------------------------
+    // move version
+
+    {
+        // value is not a table
+        toml::value v(true);
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(std::move(v), "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not the expected type
+        toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(std::move(v), "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not found
+        toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::integer>(std::move(v), "different_key"),
+                          std::out_of_range);
+    }
+    {
+        // the positive control.
+        toml::value v{{"key", 42}};
+        BOOST_TEST(42 == toml::find<int>(std::move(v), "key"));
+    }
 }

 BOOST_AUTO_TEST_CASE(test_find_recursive)
@@ -74,6 +125,9 @@ BOOST_AUTO_TEST_CASE(test_find_recursive)
        auto& num2 = toml::find<toml::integer>(v, a, b, c, d);
        num2 = 42;
        BOOST_TEST(42 == toml::find<int>(v, a, b, c, d));
+
+        auto num3 = toml::find<toml::integer>(std::move(v), a, b, c, d);
+        BOOST_TEST(42 == num3);
    }
 }

@@ -85,6 +139,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        toml::find<toml::boolean>(v, "key") = false;
        BOOST_TEST(false == toml::find<toml::boolean>(v, "key"));
+
+        const auto moved = toml::find<toml::boolean>(std::move(v), "key");
+        BOOST_TEST(false == moved);
    }
    {
        value_type v{{"key", 42}};
@@ -92,6 +149,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        toml::find<toml::integer>(v, "key") = 54;
        BOOST_TEST(toml::integer(54) == toml::find<toml::integer>(v, "key"));
+
+        const auto moved = toml::find<toml::integer>(std::move(v), "key");
+        BOOST_TEST(toml::integer(54) == moved);
    }
    {
        value_type v{{"key", 3.14}};
@@ -99,6 +159,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        toml::find<toml::floating>(v, "key") = 2.71;
        BOOST_TEST(toml::floating(2.71) == toml::find<toml::floating>(v, "key"));
+
+        const auto moved = toml::find<toml::floating>(std::move(v), "key");
+        BOOST_TEST(toml::floating(2.71) == moved);
    }
    {
        value_type v{{"key", "foo"}};
@@ -108,6 +171,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::string>(v, "key").str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::basic) ==
                          toml::find<toml::string>(v, "key"));
+
+        const auto moved = toml::find<toml::string>(std::move(v), "key");
+        BOOST_TEST(toml::string("foobar", toml::string_t::basic) == moved);
    }
    {
        value_type v{{"key", value_type("foo", toml::string_t::literal)}};
@@ -117,6 +183,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::string>(v, "key").str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::literal) ==
                          toml::find<toml::string>(v, "key"));
+
+        const auto moved = toml::find<toml::string>(std::move(v), "key");
+        BOOST_TEST(toml::string("foobar", toml::string_t::literal) == moved);
    }
    {
        toml::local_date d(2018, toml::month_t::Apr, 22);
@@ -126,6 +195,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::local_date>(v, "key").year = 2017;
        d.year = 2017;
        BOOST_CHECK(d == toml::find<toml::local_date>(v, "key"));
+
+        const auto moved = toml::find<toml::local_date>(std::move(v), "key");
+        BOOST_CHECK(d == moved);
    }
    {
        toml::local_time t(12, 30, 45);
@@ -135,6 +207,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::local_time>(v, "key").hour = 9;
        t.hour = 9;
        BOOST_CHECK(t == toml::find<toml::local_time>(v, "key"));
+
+        const auto moved = toml::find<toml::local_time>(std::move(v), "key");
+        BOOST_CHECK(t == moved);
    }
    {
        toml::local_datetime dt(toml::local_date(2018, toml::month_t::Apr, 22),
@@ -145,6 +220,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::local_datetime>(v, "key").date.year = 2017;
        dt.date.year = 2017;
        BOOST_CHECK(dt == toml::find<toml::local_datetime>(v, "key"));
+
+        const auto moved = toml::find<toml::local_datetime>(std::move(v), "key");
+        BOOST_CHECK(dt == moved);
    }
    {
        toml::offset_datetime dt(toml::local_datetime(
@@ -156,6 +234,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::offset_datetime>(v, "key").date.year = 2017;
        dt.date.year = 2017;
        BOOST_CHECK(dt == toml::find<toml::offset_datetime>(v, "key"));
+
+        const auto moved = toml::find<toml::offset_datetime>(std::move(v), "key");
+        BOOST_CHECK(dt == moved);
    }
    {
        typename value_type::array_type vec;
@@ -171,6 +252,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        const bool result2 = (vec == toml::find<typename value_type::array_type>(v, "key"));
        BOOST_CHECK(result2);
+
+        const auto moved = toml::find<typename value_type::array_type>(std::move(v), "key");
+        const bool result3 = (vec == moved);
+        BOOST_CHECK(result3);
    }
    {
        typename value_type::table_type tab;
@@ -184,6 +269,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        tab["key3"] = value_type(123);
        const bool result2 = (tab == toml::find<typename value_type::table_type>(v, "key"));
        BOOST_CHECK(result2);
+
+        const auto moved = toml::find<typename value_type::table_type>(std::move(v), "key");
+        const bool result3 = (tab == moved);
+        BOOST_CHECK(result3);
    }
    {
        value_type v1(42);
@@ -193,6 +282,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        value_type v2(54);
        toml::find(v, "key") = v2;
        BOOST_CHECK(v2 == toml::find(v, "key"));
+
+        const auto moved = toml::find(std::move(v), "key");
+        BOOST_CHECK(v2 == moved);
    }
 }

@@ -200,15 +292,16 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_integer_type, value_type, test_value_typ
 {
    {
        value_type v{{"key", 42}};
-        BOOST_TEST(int(42) ==           toml::find<int          >(v, "key"));
-        BOOST_TEST(short(42) ==         toml::find<short        >(v, "key"));
-        BOOST_TEST(char(42) ==          toml::find<char         >(v, "key"));
-        BOOST_TEST(unsigned(42) ==      toml::find<unsigned     >(v, "key"));
-        BOOST_TEST(long(42) ==          toml::find<long         >(v, "key"));
-        BOOST_TEST(std::int64_t(42) ==  toml::find<std::int64_t >(v, "key"));
+        BOOST_TEST(int(42)           == toml::find<int          >(v, "key"));
+        BOOST_TEST(short(42)         == toml::find<short        >(v, "key"));
+        BOOST_TEST(char(42)          == toml::find<char         >(v, "key"));
+        BOOST_TEST(unsigned(42)      == toml::find<unsigned     >(v, "key"));
+        BOOST_TEST(long(42)          == toml::find<long         >(v, "key"));
+        BOOST_TEST(std::int64_t(42)  == toml::find<std::int64_t >(v, "key"));
        BOOST_TEST(std::uint64_t(42) == toml::find<std::uint64_t>(v, "key"));
-        BOOST_TEST(std::int16_t(42) ==  toml::find<std::int16_t >(v, "key"));
+        BOOST_TEST(std::int16_t(42)  == toml::find<std::int16_t >(v, "key"));
        BOOST_TEST(std::uint16_t(42) == toml::find<std::uint16_t>(v, "key"));
+        BOOST_TEST(std::uint16_t(42) == toml::find<std::uint16_t>(std::move(v), "key"));
    }
 }

@@ -219,6 +312,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_floating_type, value_type, test_value_ty
        BOOST_TEST(static_cast<float      >(3.14) == toml::find<float      >(v, "key"));
        BOOST_TEST(static_cast<double     >(3.14) == toml::find<double     >(v, "key"));
        BOOST_TEST(static_cast<long double>(3.14) == toml::find<long double>(v, "key"));
+        BOOST_TEST(static_cast<float      >(3.14) == toml::find<float      >(std::move(v), "key"));
    }
 }

@@ -236,6 +330,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_string_type, value_type, test_value_type
        toml::find<std::string>(v, "key") += "bar";
        BOOST_TEST("foobar" == toml::find<std::string>(v, "key"));
    }
+    {
+        value_type v{{"key", toml::string("foo", toml::string_t::literal)}};
+        const auto moved = toml::find<std::string>(std::move(v), "key");
+        BOOST_TEST("foo" == moved);
+    }

 #if __cplusplus >= 201703L
    {
@@ -292,6 +391,53 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_array, value_type, test_value_types
    BOOST_TEST(2.71 == pr.second);
 }

+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_move_toml_array, value_type, test_value_types)
+{
+    value_type v1{{"key", {42, 54, 69, 72}}};
+    value_type v2{{"key", {42, 54, 69, 72}}};
+    value_type v3{{"key", {42, 54, 69, 72}}};
+    value_type v4{{"key", {42, 54, 69, 72}}};
+    value_type v5{{"key", {42, 54, 69, 72}}};
+
+    const std::vector<int>         vec = toml::find<std::vector<int>>(std::move(v1), "key");
+    const std::list<short>         lst = toml::find<std::list<short>>(std::move(v2), "key");
+    const std::deque<std::int64_t> deq = toml::find<std::deque<std::int64_t>>(std::move(v3), "key");
+
+    BOOST_TEST(42 == vec.at(0));
+    BOOST_TEST(54 == vec.at(1));
+    BOOST_TEST(69 == vec.at(2));
+    BOOST_TEST(72 == vec.at(3));
+
+    std::list<short>::const_iterator iter = lst.begin();
+    BOOST_TEST(static_cast<short>(42) == *(iter++));
+    BOOST_TEST(static_cast<short>(54) == *(iter++));
+    BOOST_TEST(static_cast<short>(69) == *(iter++));
+    BOOST_TEST(static_cast<short>(72) == *(iter++));
+
+    BOOST_TEST(static_cast<std::int64_t>(42) == deq.at(0));
+    BOOST_TEST(static_cast<std::int64_t>(54) == deq.at(1));
+    BOOST_TEST(static_cast<std::int64_t>(69) == deq.at(2));
+    BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));
+
+    std::array<int, 4> ary = toml::find<std::array<int, 4>>(std::move(v4), "key");
+    BOOST_TEST(static_cast<int>(42) == ary.at(0));
+    BOOST_TEST(static_cast<int>(54) == ary.at(1));
+    BOOST_TEST(static_cast<int>(69) == ary.at(2));
+    BOOST_TEST(static_cast<int>(72) == ary.at(3));
+
+    std::tuple<int, short, unsigned, long> tpl =
+        toml::find<std::tuple<int, short, unsigned, long>>(std::move(v5), "key");
+    BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+    BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
+    BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
+    BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
+
+    value_type p{{"key", {3.14, 2.71}}};
+    std::pair<double, double> pr = toml::find<std::pair<double, double> >(std::move(p), "key");
+    BOOST_TEST(3.14 == pr.first);
+    BOOST_TEST(2.71 == pr.second);
+}
+
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_array_of_array, value_type, test_value_types)
 {
    value_type v1{42, 54, 69, 72};
@@ -323,62 +469,153 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_array_of_array, value_type, test_va
    BOOST_TEST(std::get<1>(t).at(2) == "baz");
 }

+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_move_toml_array_of_array, value_type, test_value_types)
+{
+    value_type a1{42, 54, 69, 72};
+    value_type a2{"foo", "bar", "baz"};
+    value_type v1{{"key", {a1, a2}}};
+    value_type v2{{"key", {a1, a2}}};
+
+    std::pair<std::vector<int>, std::vector<std::string>> p =
+        toml::find<std::pair<std::vector<int>, std::vector<std::string>>>(std::move(v1), "key");
+
+    BOOST_TEST(p.first.at(0) == 42);
+    BOOST_TEST(p.first.at(1) == 54);
+    BOOST_TEST(p.first.at(2) == 69);
+    BOOST_TEST(p.first.at(3) == 72);
+
+    BOOST_TEST(p.second.at(0) == "foo");
+    BOOST_TEST(p.second.at(1) == "bar");
+    BOOST_TEST(p.second.at(2) == "baz");
+
+    std::tuple<std::vector<int>, std::vector<std::string>> t =
+        toml::find<std::tuple<std::vector<int>, std::vector<std::string>>>(std::move(v2), "key");
+
+    BOOST_TEST(std::get<0>(t).at(0) == 42);
+    BOOST_TEST(std::get<0>(t).at(1) == 54);
+    BOOST_TEST(std::get<0>(t).at(2) == 69);
+    BOOST_TEST(std::get<0>(t).at(3) == 72);
+
+    BOOST_TEST(std::get<1>(t).at(0) == "foo");
+    BOOST_TEST(std::get<1>(t).at(1) == "bar");
+    BOOST_TEST(std::get<1>(t).at(2) == "baz");
+}
+
+
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_table, value_type, test_value_types)
 {
-    value_type v1{{"key", {
-            {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}
-        }}};
-    const auto v = toml::find<std::map<std::string, int>>(v1, "key");
-    BOOST_TEST(v.at("key1") == 1);
-    BOOST_TEST(v.at("key2") == 2);
-    BOOST_TEST(v.at("key3") == 3);
-    BOOST_TEST(v.at("key4") == 4);
+    {
+        value_type v1{{"key", {
+                {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}
+            }}};
+        const auto v = toml::find<std::map<std::string, int>>(v1, "key");
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }
+    {
+        value_type v1{{"key", {
+                {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}
+            }}};
+        const auto v = toml::find<std::map<std::string, int>>(std::move(v1), "key");
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_local_date, value_type, test_value_types)
 {
-    value_type v1{{"key", toml::local_date{2018, toml::month_t::Apr, 1}}};
-    const auto date = std::chrono::system_clock::to_time_t(
-            toml::find<std::chrono::system_clock::time_point>(v1, "key"));
+    {
+        value_type v1{{"key", toml::local_date{2018, toml::month_t::Apr, 1}}};
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(v1, "key"));

-    std::tm t;
-    t.tm_year = 2018 - 1900;
-    t.tm_mon  = 4    - 1;
-    t.tm_mday = 1;
-    t.tm_hour = 0;
-    t.tm_min  = 0;
-    t.tm_sec  = 0;
-    t.tm_isdst = -1;
-    const auto c = std::mktime(&t);
-    BOOST_TEST(c == date);
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 0;
+        t.tm_min  = 0;
+        t.tm_sec  = 0;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
+    {
+        value_type v1{{"key", toml::local_date{2018, toml::month_t::Apr, 1}}};
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(std::move(v1), "key"));
+
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 0;
+        t.tm_min  = 0;
+        t.tm_sec  = 0;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_local_time, value_type, test_value_types)
 {
-    value_type v1{{"key", toml::local_time{12, 30, 45}}};
-    const auto time = toml::find<std::chrono::seconds>(v1, "key");
-    BOOST_CHECK(time == std::chrono::hours(12) +
-                        std::chrono::minutes(30) + std::chrono::seconds(45));
+    {
+        value_type v1{{"key", toml::local_time{12, 30, 45}}};
+        const auto time = toml::find<std::chrono::seconds>(v1, "key");
+        BOOST_CHECK(time == std::chrono::hours(12) +
+                            std::chrono::minutes(30) + std::chrono::seconds(45));
+    }
+    {
+        value_type v1{{"key", toml::local_time{12, 30, 45}}};
+        const auto time = toml::find<std::chrono::seconds>(std::move(v1), "key");
+        BOOST_CHECK(time == std::chrono::hours(12) +
+                            std::chrono::minutes(30) + std::chrono::seconds(45));
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_local_datetime, value_type, test_value_types)
 {
-    value_type v1{{"key", toml::local_datetime(
-                toml::local_date{2018, toml::month_t::Apr, 1},
-                toml::local_time{12, 30, 45})}};
+    {
+        value_type v1{{"key", toml::local_datetime(
+                    toml::local_date{2018, toml::month_t::Apr, 1},
+                    toml::local_time{12, 30, 45})}};

-    const auto date = std::chrono::system_clock::to_time_t(
-            toml::find<std::chrono::system_clock::time_point>(v1, "key"));
-    std::tm t;
-    t.tm_year = 2018 - 1900;
-    t.tm_mon  = 4    - 1;
-    t.tm_mday = 1;
-    t.tm_hour = 12;
-    t.tm_min  = 30;
-    t.tm_sec  = 45;
-    t.tm_isdst = -1;
-    const auto c = std::mktime(&t);
-    BOOST_TEST(c == date);
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(v1, "key"));
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 12;
+        t.tm_min  = 30;
+        t.tm_sec  = 45;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
+    {
+        value_type v1{{"key", toml::local_datetime(
+                    toml::local_date{2018, toml::month_t::Apr, 1},
+                    toml::local_time{12, 30, 45})}};
+
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(std::move(v1), "key"));
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 12;
+        t.tm_min  = 30;
+        t.tm_sec  = 45;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_offset_datetime, value_type, test_value_types)
@@ -428,5 +665,28 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_offset_datetime, value_type, test_va
        BOOST_TEST(tm.tm_min ==           30);
        BOOST_TEST(tm.tm_sec ==            0);
    }
+
+    {
+        value_type v1{{"key", toml::offset_datetime(
+                    toml::local_date{2018, toml::month_t::Apr, 1},
+                    toml::local_time{12, 30, 0},
+                    toml::time_offset{-8, 0})}};
+        //    2018-04-01T12:30:00-08:00
+        // == 2018-04-01T20:30:00Z
+
+        const auto date = toml::find<std::chrono::system_clock::time_point>(std::move(v1), "key");
+        const auto timet = std::chrono::system_clock::to_time_t(date);
+
+        // get time_t as gmtime (2018-04-01T03:30:00Z)
+        const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe!
+        BOOST_CHECK(tmp);
+        const auto tm = *tmp;
+        BOOST_TEST(tm.tm_year + 1900 == 2018);
+        BOOST_TEST(tm.tm_mon  + 1 ==       4);
+        BOOST_TEST(tm.tm_mday ==           1);
+        BOOST_TEST(tm.tm_hour ==          20);
+        BOOST_TEST(tm.tm_min ==           30);
+        BOOST_TEST(tm.tm_sec ==            0);
+    }
 }

--- a/tests/test_find_or.cpp
+++ b/tests/test_find_or.cpp
@@ -121,6 +121,55 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_exact, value_type, test_value_types)
 }
 #undef TOML11_TEST_FIND_OR_EXACT

+#define TOML11_TEST_FIND_OR_MOVE(toml_type, init_expr, opt_expr)   \
+    {                                                              \
+        using namespace test;                                      \
+        const toml::toml_type init init_expr ;                     \
+        toml::toml_type opt  opt_expr ;                            \
+        value_type v{{"key", init}};                               \
+        BOOST_TEST(init != opt);                                   \
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));\
+        BOOST_TEST(init == moved);                                 \
+    }                                                              \
+    /**/
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_move, value_type, test_value_types)
+{
+    TOML11_TEST_FIND_OR_MOVE(boolean,         ( true), (false))
+    TOML11_TEST_FIND_OR_MOVE(integer,         (   42), (   54))
+    TOML11_TEST_FIND_OR_MOVE(floating,        ( 3.14), ( 2.71))
+    TOML11_TEST_FIND_OR_MOVE(string,          ("foo"), ("bar"))
+    TOML11_TEST_FIND_OR_MOVE(local_time,      (12, 30, 45), (6, 0, 30))
+    TOML11_TEST_FIND_OR_MOVE(local_date,      (2019, toml::month_t::Apr, 1),
+                                              (1999, toml::month_t::Jan, 2))
+    TOML11_TEST_FIND_OR_MOVE(local_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30))
+            )
+    TOML11_TEST_FIND_OR_MOVE(offset_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45), toml::time_offset( 9, 0)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30), toml::time_offset(-3, 0))
+            )
+    {
+        typename value_type::array_type init{1,2,3,4,5};
+        typename value_type::array_type opt {6,7,8,9,10};
+        value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));
+        BOOST_TEST(init == moved);
+    }
+    {
+        typename value_type::table_type init{{"key1", 42}, {"key2", "foo"}};
+        typename value_type::table_type opt {{"key1", 54}, {"key2", "bar"}};
+        value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));
+        BOOST_TEST(init == moved);
+    }
+}
+#undef TOML11_TEST_FIND_OR_MOVE
+
+
 #define TOML11_TEST_FIND_OR_MODIFY(toml_type, init_expr, opt_expr)\
    {                                                             \
        using namespace test;                                     \
@@ -304,10 +353,20 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_fallback, value_type, test_value_type
 BOOST_AUTO_TEST_CASE(test_find_or_integer)
 {
    {
-        toml::value v = toml::table{{"num", 42}};
+        toml::value v{{"num", 42}};
        BOOST_TEST(42u == toml::find_or(v, "num", 0u));
        BOOST_TEST(0u ==  toml::find_or(v, "foo", 0u));
    }
+    {
+        toml::value v{{"num", 42}};
+        const auto moved = toml::find_or(std::move(v), "num", 0u);
+        BOOST_TEST(42u == moved);
+    }
+    {
+        toml::value v{{"num", 42}};
+        const auto moved = toml::find_or(std::move(v), "foo", 0u);
+        BOOST_TEST(0u ==  moved);
+    }
 }

 BOOST_AUTO_TEST_CASE(test_find_or_floating)
@@ -318,6 +377,14 @@ BOOST_AUTO_TEST_CASE(test_find_or_floating)
        BOOST_TEST(2.71f == toml::find_or(v1, "key", 2.71f));
        BOOST_TEST(static_cast<float>(double(3.14)) == toml::find_or(v2, "key", 2.71f));
    }
+    {
+        toml::value v1{{"key", 42}};
+        toml::value v2{{"key", 3.14}};
+        const auto moved1 = toml::find_or(std::move(v1), "key", 2.71f);
+        const auto moved2 = toml::find_or(std::move(v2), "key", 2.71f);
+        BOOST_TEST(2.71f == moved1);
+        BOOST_TEST(static_cast<float>(double(3.14)) == moved2);
+    }
 }

 BOOST_AUTO_TEST_CASE(test_find_or_string)
@@ -345,6 +412,32 @@ BOOST_AUTO_TEST_CASE(test_find_or_string)
        s1 = "bazqux"; // restoring moved value
        BOOST_TEST("bazqux" == toml::find_or(std::move(v2), "key", std::move(s1)));
    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key", 42}};
+
+        std::string s1("bazqux");
+
+        const auto moved1 = toml::find_or(std::move(v1), "key", s1);
+        const auto moved2 = toml::find_or(std::move(v2), "key", s1);
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key", 42}};
+
+        std::string s1("bazqux");
+        std::string s2("bazqux");
+
+        const auto moved1 = toml::find_or(std::move(v1), "key", std::move(s1));
+        const auto moved2 = toml::find_or(std::move(v2), "key", std::move(s2));
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+
    // string literal
    {
        toml::value v1 = toml::table{{"key", "foobar"}};
@@ -357,4 +450,90 @@ BOOST_AUTO_TEST_CASE(test_find_or_string)
        BOOST_TEST("foobar" == toml::find_or(v1, "key", lit));
        BOOST_TEST("bazqux" == toml::find_or(v2, "key", lit));
    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key",42}};
+
+        const auto moved1 = toml::find_or(std::move(v1), "key", "bazqux");
+        const auto moved2 = toml::find_or(std::move(v2), "key", "bazqux");
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key",42}};
+
+        const char* lit = "bazqux";
+        const auto moved1 = toml::find_or(std::move(v1), "key", lit);
+        const auto moved2 = toml::find_or(std::move(v2), "key", lit);
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+
+}
+
+BOOST_AUTO_TEST_CASE(test_find_or_map)
+{
+    using map_type = std::map<std::string, std::string>;
+    {
+        const toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+
+        const auto key  = toml::find_or(v1, "key",  map_type{});
+        const auto key2 = toml::find_or(v1, "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
+    {
+        toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+
+        const auto key  = toml::find_or<map_type>(v1, "key",  map_type{});
+        const auto key2 = toml::find_or<map_type>(v1, "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
+
+    {
+        toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+        toml::value v2(v1);
+
+        const auto key  = toml::find_or(std::move(v1), "key",  map_type{});
+        const auto key2 = toml::find_or(std::move(v2), "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
+    {
+        toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+        toml::value v2(v1);
+
+        const auto key  = toml::find_or<map_type>(std::move(v1), "key",  map_type{});
+        const auto key2 = toml::find_or<map_type>(std::move(v2), "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
 }
--- a/tests/test_format_error.cpp
+++ b/tests/test_format_error.cpp
@@ -6,6 +6,7 @@
 #include <boost/test/included/unit_test.hpp>
 #endif
 #include <toml.hpp>
+#include <iostream>

 // to check it successfully compiles. it does not check the formatted string.

--- a/tests/test_get.cpp
+++ b/tests/test_get.cpp
@@ -31,6 +31,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)

        toml::get<toml::boolean>(v) = false;
        BOOST_TEST(false == toml::get<toml::boolean>(v));
+
+        toml::boolean x = toml::get<toml::boolean>(std::move(v));
+        BOOST_TEST(false == x);
    }
    {
        value_type v(42);
@@ -38,6 +41,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)

        toml::get<toml::integer>(v) = 54;
        BOOST_TEST(toml::integer(54) == toml::get<toml::integer>(v));
+
+        toml::integer x = toml::get<toml::integer>(std::move(v));
+        BOOST_TEST(toml::integer(54) == x);
    }
    {
        value_type v(3.14);
@@ -45,6 +51,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)

        toml::get<toml::floating>(v) = 2.71;
        BOOST_TEST(toml::floating(2.71) == toml::get<toml::floating>(v));
+
+        toml::floating x = toml::get<toml::floating>(std::move(v));
+        BOOST_TEST(toml::floating(2.71) == x);
    }
    {
        value_type v("foo");
@@ -54,6 +63,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::string>(v).str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::basic) ==
                          toml::get<toml::string>(v));
+
+        toml::string x = toml::get<toml::string>(std::move(v));
+        BOOST_TEST(toml::string("foobar") == x);
    }
    {
        value_type v("foo", toml::string_t::literal);
@@ -63,6 +75,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::string>(v).str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::literal) ==
                          toml::get<toml::string>(v));
+
+        toml::string x = toml::get<toml::string>(std::move(v));
+        BOOST_TEST(toml::string("foobar", toml::string_t::literal) == x);
    }
    {
        toml::local_date d(2018, toml::month_t::Apr, 22);
@@ -72,6 +87,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::local_date>(v).year = 2017;
        d.year = 2017;
        BOOST_TEST(d == toml::get<toml::local_date>(v));
+
+        toml::local_date x = toml::get<toml::local_date>(std::move(v));
+        BOOST_TEST(d == x);
    }
    {
        toml::local_time t(12, 30, 45);
@@ -81,6 +99,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::local_time>(v).hour = 9;
        t.hour = 9;
        BOOST_TEST(t == toml::get<toml::local_time>(v));
+
+        toml::local_time x = toml::get<toml::local_time>(std::move(v));
+        BOOST_TEST(t == x);
    }
    {
        toml::local_datetime dt(toml::local_date(2018, toml::month_t::Apr, 22),
@@ -91,6 +112,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::local_datetime>(v).date.year = 2017;
        dt.date.year = 2017;
        BOOST_TEST(dt == toml::get<toml::local_datetime>(v));
+
+        toml::local_datetime x = toml::get<toml::local_datetime>(std::move(v));
+        BOOST_TEST(dt == x);
    }
    {
        toml::offset_datetime dt(toml::local_datetime(
@@ -102,6 +126,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::offset_datetime>(v).date.year = 2017;
        dt.date.year = 2017;
        BOOST_TEST(dt == toml::get<toml::offset_datetime>(v));
+
+        toml::offset_datetime x = toml::get<toml::offset_datetime>(std::move(v));
+        BOOST_TEST(dt == x);
    }
    {
        using array_type = typename value_type::array_type;
@@ -114,6 +141,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<array_type>(v).push_back(value_type(123));
        vec.push_back(value_type(123));
        BOOST_TEST(vec == toml::get<array_type>(v));
+
+        array_type x = toml::get<array_type>(std::move(v));
+        BOOST_TEST(vec == x);
    }
    {
        using table_type = typename value_type::table_type;
@@ -126,6 +156,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<table_type>(v)["key3"] = value_type(123);
        tab["key3"] = value_type(123);
        BOOST_TEST(tab == toml::get<table_type>(v));
+
+        table_type x = toml::get<table_type>(std::move(v));
+        BOOST_TEST(tab == x);
    }
    {
        value_type v1(42);
@@ -134,6 +167,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        value_type v2(54);
        toml::get<value_type>(v1) = v2;
        BOOST_TEST(v2 == toml::get<value_type>(v1));
+
+        value_type x = toml::get<value_type>(std::move(v1));
+        BOOST_TEST(v2 == x);
    }
 }

@@ -150,6 +186,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_integer_type, value_type, test_value_type
        BOOST_TEST(std::uint64_t(42) == toml::get<std::uint64_t>(v));
        BOOST_TEST(std::int16_t(42) ==  toml::get<std::int16_t >(v));
        BOOST_TEST(std::uint16_t(42) == toml::get<std::uint16_t>(v));
+
+        BOOST_TEST(std::uint16_t(42) == toml::get<std::uint16_t>(std::move(v)));
    }
 }

@@ -160,6 +198,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_floating_type, value_type, test_value_typ
        BOOST_TEST(static_cast<float      >(3.14) == toml::get<float      >(v));
        BOOST_TEST(static_cast<double     >(3.14) == toml::get<double     >(v));
        BOOST_TEST(static_cast<long double>(3.14) == toml::get<long double>(v));
+
+        BOOST_TEST(3.14f == toml::get<float>(std::move(v)));
    }
 }

@@ -170,12 +210,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_string_type, value_type, test_value_types
        BOOST_TEST("foo" == toml::get<std::string>(v));
        toml::get<std::string>(v) += "bar";
        BOOST_TEST("foobar" == toml::get<std::string>(v));
+
+        const auto x = toml::get<std::string>(std::move(v));
+        BOOST_TEST("foobar" == x);
    }
    {
        value_type v("foo", toml::string_t::literal);
        BOOST_TEST("foo" == toml::get<std::string>(v));
        toml::get<std::string>(v) += "bar";
        BOOST_TEST("foobar" == toml::get<std::string>(v));
+
+        const auto x = toml::get<std::string>(std::move(v));
+        BOOST_TEST("foobar" == x);
    }

 #if __cplusplus >= 201703L
@@ -192,92 +238,176 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_string_type, value_type, test_value_types

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array, value_type, test_value_types)
 {
-    const value_type v{42, 54, 69, 72};
+    {
+        const value_type v{42, 54, 69, 72};

-    const std::vector<int>         vec = toml::get<std::vector<int>>(v);
-    const std::list<short>         lst = toml::get<std::list<short>>(v);
-    const std::deque<std::int64_t> deq = toml::get<std::deque<std::int64_t>>(v);
+        const std::vector<int>         vec = toml::get<std::vector<int>>(v);
+        const std::list<short>         lst = toml::get<std::list<short>>(v);
+        const std::deque<std::int64_t> deq = toml::get<std::deque<std::int64_t>>(v);

-    BOOST_TEST(42 == vec.at(0));
-    BOOST_TEST(54 == vec.at(1));
-    BOOST_TEST(69 == vec.at(2));
-    BOOST_TEST(72 == vec.at(3));
+        BOOST_TEST(42 == vec.at(0));
+        BOOST_TEST(54 == vec.at(1));
+        BOOST_TEST(69 == vec.at(2));
+        BOOST_TEST(72 == vec.at(3));

-    std::list<short>::const_iterator iter = lst.begin();
-    BOOST_TEST(static_cast<short>(42) == *(iter++));
-    BOOST_TEST(static_cast<short>(54) == *(iter++));
-    BOOST_TEST(static_cast<short>(69) == *(iter++));
-    BOOST_TEST(static_cast<short>(72) == *(iter++));
+        std::list<short>::const_iterator iter = lst.begin();
+        BOOST_TEST(static_cast<short>(42) == *(iter++));
+        BOOST_TEST(static_cast<short>(54) == *(iter++));
+        BOOST_TEST(static_cast<short>(69) == *(iter++));
+        BOOST_TEST(static_cast<short>(72) == *(iter++));

-    BOOST_TEST(static_cast<std::int64_t>(42) == deq.at(0));
-    BOOST_TEST(static_cast<std::int64_t>(54) == deq.at(1));
-    BOOST_TEST(static_cast<std::int64_t>(69) == deq.at(2));
-    BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));
+        BOOST_TEST(static_cast<std::int64_t>(42) == deq.at(0));
+        BOOST_TEST(static_cast<std::int64_t>(54) == deq.at(1));
+        BOOST_TEST(static_cast<std::int64_t>(69) == deq.at(2));
+        BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));

-    std::array<int, 4> ary = toml::get<std::array<int, 4>>(v);
-    BOOST_TEST(static_cast<int>(42) == ary.at(0));
-    BOOST_TEST(static_cast<int>(54) == ary.at(1));
-    BOOST_TEST(static_cast<int>(69) == ary.at(2));
-    BOOST_TEST(static_cast<int>(72) == ary.at(3));
+        std::array<int, 4> ary = toml::get<std::array<int, 4>>(v);
+        BOOST_TEST(static_cast<int>(42) == ary.at(0));
+        BOOST_TEST(static_cast<int>(54) == ary.at(1));
+        BOOST_TEST(static_cast<int>(69) == ary.at(2));
+        BOOST_TEST(static_cast<int>(72) == ary.at(3));

-    std::tuple<int, short, unsigned, long> tpl =
-        toml::get<std::tuple<int, short, unsigned, long>>(v);
-    BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
-    BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
-    BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
-    BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
+        std::tuple<int, short, unsigned, long> tpl =
+            toml::get<std::tuple<int, short, unsigned, long>>(v);
+        BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+        BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
+        BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
+        BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));

-    const value_type p{3.14, 2.71};
-    std::pair<double, double> pr = toml::get<std::pair<double, double> >(p);
-    BOOST_TEST(3.14 == pr.first);
-    BOOST_TEST(2.71 == pr.second);
+        const value_type p{3.14, 2.71};
+        std::pair<double, double> pr = toml::get<std::pair<double, double> >(p);
+        BOOST_TEST(3.14 == pr.first);
+        BOOST_TEST(2.71 == pr.second);
+    }
+
+    {
+        value_type v{42, 54, 69, 72};
+        const std::vector<int> vec = toml::get<std::vector<int>>(std::move(v));
+        BOOST_TEST(42 == vec.at(0));
+        BOOST_TEST(54 == vec.at(1));
+        BOOST_TEST(69 == vec.at(2));
+        BOOST_TEST(72 == vec.at(3));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        const std::deque<int> deq = toml::get<std::deque<int>>(std::move(v));
+        BOOST_TEST(42 == deq.at(0));
+        BOOST_TEST(54 == deq.at(1));
+        BOOST_TEST(69 == deq.at(2));
+        BOOST_TEST(72 == deq.at(3));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        const std::list<int> lst = toml::get<std::list<int>>(std::move(v));
+        std::list<int>::const_iterator iter = lst.begin();
+        BOOST_TEST(42 == *(iter++));
+        BOOST_TEST(54 == *(iter++));
+        BOOST_TEST(69 == *(iter++));
+        BOOST_TEST(72 == *(iter++));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        std::array<int, 4> ary = toml::get<std::array<int, 4>>(std::move(v));
+        BOOST_TEST(static_cast<int>(42) == ary.at(0));
+        BOOST_TEST(static_cast<int>(54) == ary.at(1));
+        BOOST_TEST(static_cast<int>(69) == ary.at(2));
+        BOOST_TEST(static_cast<int>(72) == ary.at(3));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        std::tuple<int, short, unsigned, long> tpl =
+            toml::get<std::tuple<int, short, unsigned, long>>(std::move(v));
+        BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+        BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
+        BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
+        BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array_of_array, value_type, test_value_types)
 {
-    const value_type v1{42, 54, 69, 72};
-    const value_type v2{"foo", "bar", "baz"};
-    const value_type v{v1, v2};
+    {
+        const value_type v1{42, 54, 69, 72};
+        const value_type v2{"foo", "bar", "baz"};
+        const value_type v{v1, v2};

-    std::pair<std::vector<int>, std::vector<std::string>> p =
-        toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(v);
+        std::pair<std::vector<int>, std::vector<std::string>> p =
+            toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(v);

-    BOOST_TEST(p.first.at(0) == 42);
-    BOOST_TEST(p.first.at(1) == 54);
-    BOOST_TEST(p.first.at(2) == 69);
-    BOOST_TEST(p.first.at(3) == 72);
+        BOOST_TEST(p.first.size() == 4u);
+        BOOST_TEST(p.first.at(0) == 42);
+        BOOST_TEST(p.first.at(1) == 54);
+        BOOST_TEST(p.first.at(2) == 69);
+        BOOST_TEST(p.first.at(3) == 72);

-    BOOST_TEST(p.second.at(0) == "foo");
-    BOOST_TEST(p.second.at(1) == "bar");
-    BOOST_TEST(p.second.at(2) == "baz");
+        BOOST_TEST(p.second.size() == 3u);
+        BOOST_TEST(p.second.at(0) == "foo");
+        BOOST_TEST(p.second.at(1) == "bar");
+        BOOST_TEST(p.second.at(2) == "baz");

-    std::tuple<std::vector<int>, std::vector<std::string>> t =
-        toml::get<std::tuple<std::vector<int>, std::vector<std::string>>>(v);
+        std::tuple<std::vector<int>, std::vector<std::string>> t =
+            toml::get<std::tuple<std::vector<int>, std::vector<std::string>>>(v);

-    BOOST_TEST(std::get<0>(t).at(0) == 42);
-    BOOST_TEST(std::get<0>(t).at(1) == 54);
-    BOOST_TEST(std::get<0>(t).at(2) == 69);
-    BOOST_TEST(std::get<0>(t).at(3) == 72);
+        BOOST_TEST(std::get<0>(t).at(0) == 42);
+        BOOST_TEST(std::get<0>(t).at(1) == 54);
+        BOOST_TEST(std::get<0>(t).at(2) == 69);
+        BOOST_TEST(std::get<0>(t).at(3) == 72);

-    BOOST_TEST(std::get<1>(t).at(0) == "foo");
-    BOOST_TEST(std::get<1>(t).at(1) == "bar");
-    BOOST_TEST(std::get<1>(t).at(2) == "baz");
+        BOOST_TEST(std::get<1>(t).at(0) == "foo");
+        BOOST_TEST(std::get<1>(t).at(1) == "bar");
+        BOOST_TEST(std::get<1>(t).at(2) == "baz");
+    }
+    {
+        const value_type v1{42, 54, 69, 72};
+        const value_type v2{"foo", "bar", "baz"};
+        value_type v{v1, v2};
+
+        std::pair<std::vector<int>, std::vector<std::string>> p =
+            toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(std::move(v));
+
+        BOOST_TEST(p.first.size() == 4u);
+        BOOST_TEST(p.first.at(0) == 42);
+        BOOST_TEST(p.first.at(1) == 54);
+        BOOST_TEST(p.first.at(2) == 69);
+        BOOST_TEST(p.first.at(3) == 72);
+
+        BOOST_TEST(p.second.size() == 3u);
+        BOOST_TEST(p.second.at(0) == "foo");
+        BOOST_TEST(p.second.at(1) == "bar");
+        BOOST_TEST(p.second.at(2) == "baz");
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_table, value_type, test_value_types)
 {
-    const value_type v1{
-            {"key1", 1},
-            {"key2", 2},
-            {"key3", 3},
-            {"key4", 4}
-        };
+    {
+        const value_type v1{
+                {"key1", 1},
+                {"key2", 2},
+                {"key3", 3},
+                {"key4", 4}
+            };
+
+        const auto v = toml::get<std::map<std::string, int>>(v1);
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }
+    {
+        value_type v1{
+                {"key1", 1},
+                {"key2", 2},
+                {"key3", 3},
+                {"key4", 4}
+            };
+        const auto v = toml::get<std::map<std::string, int>>(std::move(v1));
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }

-    const auto v = toml::get<std::map<std::string, int>>(v1);
-    BOOST_TEST(v.at("key1") == 1);
-    BOOST_TEST(v.at("key2") == 2);
-    BOOST_TEST(v.at("key3") == 3);
-    BOOST_TEST(v.at("key4") == 4);
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_local_date, value_type, test_value_types)
--- a/tests/test_get_or.cpp
+++ b/tests/test_get_or.cpp
@@ -25,6 +25,11 @@ using test_value_types = std::tuple<

 namespace test
 {
+// to compare result values in BOOST_TEST().
+//
+// BOOST_TEST outputs the expected and actual values. Thus it includes the
+// output stream operator inside. To compile it, we need operator<<s for
+// containers to compare.
 template<typename charT, typename traits, typename T, typename Alloc>
 std::basic_ostream<charT, traits>&
 operator<<(std::basic_ostream<charT, traits>& os, const std::vector<T, Alloc>& v)
@@ -121,6 +126,55 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_or_exact, value_type, test_value_types)
 }
 #undef TOML11_TEST_GET_OR_EXACT

+#define TOML11_TEST_GET_OR_MOVE_EXACT(toml_type, init_expr, opt_expr)\
+    {                                                                \
+        using namespace test;                                        \
+        const toml::toml_type init init_expr ;                       \
+        toml::toml_type       opt  opt_expr ;                        \
+        value_type v(init);                                          \
+        BOOST_TEST(init != opt);                                     \
+        const auto opt_ = toml::get_or(std::move(v), std::move(opt));\
+        BOOST_TEST(init == opt_);                                    \
+    }                                                                \
+    /**/
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_or_move, value_type, test_value_types)
+{
+    TOML11_TEST_GET_OR_MOVE_EXACT(boolean,         ( true), (false))
+    TOML11_TEST_GET_OR_MOVE_EXACT(integer,         (   42), (   54))
+    TOML11_TEST_GET_OR_MOVE_EXACT(floating,        ( 3.14), ( 2.71))
+    TOML11_TEST_GET_OR_MOVE_EXACT(string,          ("foo"), ("bar"))
+    TOML11_TEST_GET_OR_MOVE_EXACT(local_time,      (12, 30, 45), (6, 0, 30))
+    TOML11_TEST_GET_OR_MOVE_EXACT(local_date,      (2019, toml::month_t::Apr, 1),
+                                                   (1999, toml::month_t::Jan, 2))
+    TOML11_TEST_GET_OR_MOVE_EXACT(local_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30))
+            )
+    TOML11_TEST_GET_OR_MOVE_EXACT(offset_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45), toml::time_offset( 9, 0)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30), toml::time_offset(-3, 0))
+            )
+    {
+        const typename value_type::array_type init{1,2,3,4,5};
+        typename value_type::array_type opt {6,7,8,9,10};
+        value_type v(init);
+        BOOST_TEST(init != opt);
+        const auto opt_ = toml::get_or(std::move(v), std::move(opt));
+        BOOST_TEST(init == opt_);
+    }
+    {
+        const typename value_type::table_type init{{"key1", 42}, {"key2", "foo"}};
+        typename value_type::table_type opt {{"key1", 54}, {"key2", "bar"}};
+        value_type v(init);
+        BOOST_TEST(init != opt);
+        const auto opt_ = toml::get_or(std::move(v), std::move(opt));
+        BOOST_TEST(init == opt_);
+    }
+}
+#undef TOML11_TEST_GET_OR_MOVE_EXACT
+
+
 #define TOML11_TEST_GET_OR_MODIFY(toml_type, init_expr, opt_expr)\
    {                                                            \
        using namespace test;                                    \
@@ -309,6 +363,13 @@ BOOST_AUTO_TEST_CASE(test_get_or_integer)
        BOOST_TEST(42u == toml::get_or(v1, 0u));
        BOOST_TEST(0u ==  toml::get_or(v2, 0u));
    }
+    {
+        toml::value v1(42);
+        toml::value v2(3.14);
+        BOOST_TEST(42u == toml::get_or(std::move(v1), 0u));
+        BOOST_TEST(0u ==  toml::get_or(std::move(v2), 0u));
+    }
+
 }

 BOOST_AUTO_TEST_CASE(test_get_or_floating)
@@ -319,6 +380,12 @@ BOOST_AUTO_TEST_CASE(test_get_or_floating)
        BOOST_TEST(2.71f == toml::get_or(v1, 2.71f));
        BOOST_TEST(static_cast<float>(v2.as_floating()) == toml::get_or(v2, 2.71f));
    }
+    {
+        toml::value v1(42);
+        toml::value v2(3.14);
+        BOOST_TEST(2.71f                    == toml::get_or(std::move(v1), 2.71f));
+        BOOST_TEST(static_cast<float>(3.14) == toml::get_or(std::move(v2), 2.71f));
+    }
 }

 BOOST_AUTO_TEST_CASE(test_get_or_string)
@@ -345,7 +412,16 @@ BOOST_AUTO_TEST_CASE(test_get_or_string)
        BOOST_TEST("foobar" == toml::get_or(v1, std::move(s1)));
        BOOST_TEST("bazqux" == toml::get_or(v2, std::move(s1)));
    }
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);

+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_TEST("foobar" == toml::get_or(std::move(v1), s1));
+        BOOST_TEST("bazqux" == toml::get_or(std::move(v2), s1));
+    }
    {
        toml::value v1("foobar");
        toml::value v2(42);
@@ -357,4 +433,20 @@ BOOST_AUTO_TEST_CASE(test_get_or_string)
        BOOST_TEST("foobar" == toml::get_or(v1, lit));
        BOOST_TEST("bazqux" == toml::get_or(v2, lit));
    }
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        BOOST_TEST("foobar" == toml::get_or(std::move(v1), "bazqux"));
+        BOOST_TEST("bazqux" == toml::get_or(std::move(v2), "bazqux"));
+    }
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        const char* lit = "bazqux";
+        BOOST_TEST("foobar" == toml::get_or(v1, lit));
+        BOOST_TEST("bazqux" == toml::get_or(v2, lit));
+    }
+
 }
--- a/tests/test_lex_floating.cpp
+++ b/tests/test_lex_floating.cpp
@@ -35,27 +35,35 @@ BOOST_AUTO_TEST_CASE(test_fractional_invalid)

 BOOST_AUTO_TEST_CASE(test_exponential_valid)
 {
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e10",       "1e10");      
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e+10",      "1e+10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e-10",      "1e-10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e10",      "+1e10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e+10",     "+1e+10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e-10",     "+1e-10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e10",      "-1e10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e+10",     "-1e+10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e-10",     "-1e-10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "123e-10",    "123e-10");   
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1E10",       "1E10");      
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1E+10",      "1E+10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1E-10",      "1E-10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "123E-10",    "123E-10");   
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-10",  "1_2_3E-10"); 
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e10",       "1e10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e+10",      "1e+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e-10",      "1e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e10",      "+1e10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e+10",     "+1e+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e-10",     "+1e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e10",      "-1e10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e+10",     "-1e+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e-10",     "-1e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "123e-10",    "123e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1E10",       "1E10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1E+10",      "1E+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1E-10",      "1E-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "123E-10",    "123E-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-10",  "1_2_3E-10");
    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-1_0", "1_2_3E-1_0");
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-01",  "1_2_3E-01");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-0_1", "1_2_3E-0_1");
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_exponential_invalid)
 {
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1E0", "1e1"); 
+    // accept partially
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1E0", "1e1");
    TOML11_TEST_LEX_ACCEPT(lex_float, "1E1e0", "1E1");
 }

@@ -64,12 +72,26 @@ BOOST_AUTO_TEST_CASE(test_both_valid)
    TOML11_TEST_LEX_ACCEPT(lex_float, "6.02e23",          "6.02e23");
    TOML11_TEST_LEX_ACCEPT(lex_float, "6.02e+23",         "6.02e+23");
    TOML11_TEST_LEX_ACCEPT(lex_float, "1.112_650_06e-17", "1.112_650_06e-17");
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1.0e-07",          "1.0e-07");
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_both_invalid)
 {
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1.0",  "1e1");
    TOML11_TEST_LEX_REJECT(lex_float, "01e1.0");
+    // accept partially
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1.0",  "1e1");
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1.0e_01",  "1.0");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1.0e0__1", "1.0e0");
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_special_floating_point)
--- a/tests/test_literals.cpp
+++ b/tests/test_literals.cpp
@@ -45,6 +45,16 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
            b = "baz"
        )"_toml;

+        BOOST_TEST(r == v);
+    }
+    {
+        const toml::value r{
+            {"array_of_tables", toml::array{toml::table{}}}
+        };
+        const toml::value v = u8R"(
+            [[array_of_tables]]
+        )"_toml;
+
        BOOST_TEST(r == v);
    }
 }
--- a/tests/test_parse_array.cpp
+++ b/tests/test_parse_array.cpp
@@ -128,3 +128,47 @@ BOOST_AUTO_TEST_CASE(test_multiline_array_value)
        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", toml::value(a));
    }
 }
+
+BOOST_AUTO_TEST_CASE(test_heterogeneous_array)
+{
+#ifndef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("In strict TOML v0.5.0, heterogeneous arrays are not allowed.");
+#else
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\", 3.14, 42, [\"array\", \"of\", \"hetero-array\", 1], {key = \"value\"}]", toml::value(a));
+    }
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",\n 3.14,\n 42,\n [\"array\", \"of\", \"hetero-array\", 1],\n {key = \"value\"},\n]", toml::value(a));
+    }
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",#comment\n 3.14,#comment\n 42,#comment\n [\"array\", \"of\", \"hetero-array\", 1],#comment\n {key = \"value\"},#comment\n]#comment", toml::value(a));
+    }
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",\n 3.14,\n 42,\n [\"array\",\n \"of\",\n \"hetero-array\",\n 1],\n {key = \"value\"},\n]", toml::value(a));
+    }
+#endif
+}
--- a/tests/test_parse_floating.cpp
+++ b/tests/test_parse_floating.cpp
@@ -68,6 +68,13 @@ BOOST_AUTO_TEST_CASE(test_exponential)
    TOML11_TEST_PARSE_EQUAL(parse_floating, "1_2_3E-1_0", 123e-10);
    TOML11_TEST_PARSE_EQUAL(parse_floating, "+0e0",        0.0);
    TOML11_TEST_PARSE_EQUAL(parse_floating, "-0e0",       -0.0);
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_PARSE_EQUAL(parse_floating, "1_2_3E-01",  123e-1);
+    TOML11_TEST_PARSE_EQUAL(parse_floating, "1_2_3E-0_1", 123e-1);
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_exponential_value)
@@ -90,6 +97,13 @@ BOOST_AUTO_TEST_CASE(test_exponential_value)
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1_2_3E-1_0", value(123e-10));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "+0e0",       value( 0.0));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "-0e0",       value(-0.0));
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1_2_3E-01",  value(123e-1));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1_2_3E-0_1", value(123e-1));
+#endif
 }
 BOOST_AUTO_TEST_CASE(test_fe)
 {
@@ -102,6 +116,12 @@ BOOST_AUTO_TEST_CASE(test_fe_vaule)
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "6.02e23",          value(6.02e23));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "6.02e+23",         value(6.02e23));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1.112_650_06e-17", value(1.11265006e-17));
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "3.141_5e-01",      value(3.1415e-1));
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_inf)
--- a/tests/test_string.cpp
+++ b/tests/test_string.cpp
@@ -111,3 +111,44 @@ BOOST_AUTO_TEST_CASE(test_literal_ml_string)
    }
 }

+BOOST_AUTO_TEST_CASE(test_string_add_assign)
+{
+    // string literal
+    {
+        toml::string str("foo");
+        str += "bar";
+        BOOST_TEST(str.str == "foobar");
+    }
+    // std::string
+    {
+        toml::string str("foo");
+        std::string str2("bar");
+        str += str2;
+        BOOST_TEST(str.str == "foobar");
+    }
+    // toml::string
+    {
+        toml::string str("foo");
+        toml::string str2("bar");
+        str += str2;
+        BOOST_TEST(str.str == "foobar");
+    }
+#if __cplusplus >= 201703L
+    // std::string_view
+    {
+        toml::string str("foo");
+        str += std::string_view("bar");
+        BOOST_TEST(str == "foobar");
+    }
+#endif
+    // std::string += toml::string
+    {
+        std::string  str("foo");
+        toml::string str2("bar");
+        str += str2;
+        BOOST_TEST(str == "foobar");
+    }
+
+
+}
+
--- a/tests/test_value.cpp
+++ b/tests/test_value.cpp
@@ -905,3 +905,64 @@ BOOST_AUTO_TEST_CASE(test_value_empty)
    BOOST_CHECK_THROW(v1.as_array(),           toml::type_error);
    BOOST_CHECK_THROW(v1.as_table(),           toml::type_error);
 }
+
+
+BOOST_AUTO_TEST_CASE(test_value_at)
+{
+    {
+        toml::value v1{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}};
+
+        BOOST_TEST(v1.at("foo").as_integer()  == 42);
+        BOOST_TEST(v1.at("bar").as_floating() == 3.14);
+        BOOST_TEST(v1.at("baz").as_string()   == "qux");
+
+        BOOST_CHECK_THROW(v1.at(0), toml::type_error);
+        BOOST_CHECK_THROW(v1.at("quux"), std::out_of_range);
+    }
+
+
+    {
+        toml::value v1{1,2,3,4,5};
+
+        BOOST_TEST(v1.at(0).as_integer() == 1);
+        BOOST_TEST(v1.at(1).as_integer() == 2);
+        BOOST_TEST(v1.at(2).as_integer() == 3);
+        BOOST_TEST(v1.at(3).as_integer() == 4);
+        BOOST_TEST(v1.at(4).as_integer() == 5);
+
+        BOOST_CHECK_THROW(v1.at("foo"), toml::type_error);
+        BOOST_CHECK_THROW(v1.at(5),     std::out_of_range);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_value_bracket)
+{
+    {
+        toml::value v1{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}};
+
+        BOOST_TEST(v1["foo"].as_integer()  == 42);
+        BOOST_TEST(v1["bar"].as_floating() == 3.14);
+        BOOST_TEST(v1["baz"].as_string()   == "qux");
+
+        v1["qux"] = 54;
+        BOOST_TEST(v1["qux"].as_integer()  == 54);
+    }
+    {
+        toml::value v1;
+        v1["foo"] = 42;
+
+        BOOST_TEST(v1.is_table());
+        BOOST_TEST(v1["foo"].as_integer()  == 42);
+    }
+    {
+        toml::value v1{1,2,3,4,5};
+
+        BOOST_TEST(v1[0].as_integer() == 1);
+        BOOST_TEST(v1[1].as_integer() == 2);
+        BOOST_TEST(v1[2].as_integer() == 3);
+        BOOST_TEST(v1[3].as_integer() == 4);
+        BOOST_TEST(v1[4].as_integer() == 5);
+
+        BOOST_CHECK_THROW(v1["foo"], toml::type_error);
+    }
+}
--- a/toml/color.hpp
+++ b/toml/color.hpp
@@ -0,0 +1,64 @@
+#ifndef TOML11_COLOR_HPP
+#define TOML11_COLOR_HPP
+#include <ostream>
+#include <cstdint>
+
+#ifdef TOML11_COLORIZE_ERROR_MESSAGE
+#define TOML11_ERROR_MESSAGE_COLORIZED true
+#else
+#define TOML11_ERROR_MESSAGE_COLORIZED false
+#endif
+
+namespace toml
+{
+
+// put ANSI escape sequence to ostream
+namespace color_ansi
+{
+namespace detail
+{
+inline int colorize_index()
+{
+    static const int index = std::ios_base::xalloc();
+    return index;
+}
+} // detail
+
+inline std::ostream& colorize(std::ostream& os)
+{
+    // by default, it is zero.
+    os.iword(detail::colorize_index()) = 1;
+    return os;
+}
+inline std::ostream& nocolorize(std::ostream& os)
+{
+    os.iword(detail::colorize_index()) = 0;
+    return os;
+}
+inline std::ostream& reset  (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[00m";} return os;}
+inline std::ostream& bold   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[01m";} return os;}
+inline std::ostream& grey   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[30m";} return os;}
+inline std::ostream& red    (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[31m";} return os;}
+inline std::ostream& green  (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[32m";} return os;}
+inline std::ostream& yellow (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[33m";} return os;}
+inline std::ostream& blue   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[34m";} return os;}
+inline std::ostream& magenta(std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[35m";} return os;}
+inline std::ostream& cyan   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[36m";} return os;}
+inline std::ostream& white  (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[37m";} return os;}
+} // color_ansi
+
+// ANSI escape sequence is the only and default colorization method currently
+namespace color = color_ansi;
+
+} // toml
+#endif// TOML11_COLOR_HPP
--- a/toml/combinator.hpp
+++ b/toml/combinator.hpp
@@ -45,6 +45,7 @@ inline std::string show_char(const char c)
        buf.fill('\0');
        const auto r = std::snprintf(
                buf.data(), buf.size(), "0x%02x", static_cast<int>(c) & 0xFF);
+        (void) r; // Unused variable warning
        assert(r == static_cast<int>(buf.size()) - 1);
        return std::string(buf.data());
    }
--- a/toml/datetime.hpp
+++ b/toml/datetime.hpp
@@ -20,7 +20,7 @@ namespace toml
 namespace detail
 {
 // TODO: find more sophisticated way to handle this
-#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE || _POSIX_SOURCE
+#if _POSIX_C_SOURCE >= 1 || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || defined(_POSIX_SOURCE)
 inline std::tm localtime_s(const std::time_t* src)
 {
    std::tm dst;
@@ -28,6 +28,13 @@ inline std::tm localtime_s(const std::time_t* src)
    if (!result) { throw std::runtime_error("localtime_r failed."); }
    return dst;
 }
+inline std::tm gmtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::gmtime_r(src, &dst);
+    if (!result) { throw std::runtime_error("gmtime_r failed."); }
+    return dst;
+}
 #elif _MSC_VER
 inline std::tm localtime_s(const std::time_t* src)
 {
@@ -36,13 +43,26 @@ inline std::tm localtime_s(const std::time_t* src)
    if (result) { throw std::runtime_error("localtime_s failed."); }
    return dst;
 }
-#else
+inline std::tm gmtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::gmtime_s(&dst, src);
+    if (result) { throw std::runtime_error("gmtime_s failed."); }
+    return dst;
+}
+#else // fallback. not threadsafe
 inline std::tm localtime_s(const std::time_t* src)
 {
    const auto result = std::localtime(src);
    if (!result) { throw std::runtime_error("localtime failed."); }
    return *result;
 }
+inline std::tm gmtime_s(const std::time_t* src)
+{
+    const auto result = std::gmtime(src);
+    if (!result) { throw std::runtime_error("gmtime failed."); }
+    return *result;
+}
 #endif
 } // detail

@@ -378,10 +398,31 @@ struct local_datetime
    {
        using internal_duration =
            typename std::chrono::system_clock::time_point::duration;
+
+        // Normally DST begins at A.M. 3 or 4. If we re-use conversion operator
+        // of local_date and local_time independently, the conversion fails if
+        // it is the day when DST begins or ends. Since local_date considers the
+        // time is 00:00 A.M. and local_time does not consider DST because it
+        // does not have any date information. We need to consider both date and
+        // time information at the same time to convert it correctly.
+
+        std::tm t;
+        t.tm_sec   = static_cast<int>(this->time.second);
+        t.tm_min   = static_cast<int>(this->time.minute);
+        t.tm_hour  = static_cast<int>(this->time.hour);
+        t.tm_mday  = static_cast<int>(this->date.day);
+        t.tm_mon   = static_cast<int>(this->date.month);
+        t.tm_year  = static_cast<int>(this->date.year) - 1900;
+        t.tm_wday  = 0; // the value will be ignored
+        t.tm_yday  = 0; // the value will be ignored
+        t.tm_isdst = -1;
+
        // std::mktime returns date as local time zone. no conversion needed
-        auto dt = std::chrono::system_clock::time_point(this->date);
+        auto dt = std::chrono::system_clock::from_time_t(std::mktime(&t));
        dt += std::chrono::duration_cast<internal_duration>(
-                   std::chrono::nanoseconds(this->time));
+                std::chrono::milliseconds(this->time.millisecond) +
+                std::chrono::microseconds(this->time.microsecond) +
+                std::chrono::nanoseconds (this->time.nanosecond));
        return dt;
    }

@@ -447,40 +488,71 @@ struct offset_datetime
        : date(dt.date), time(dt.time), offset(o)
    {}
    explicit offset_datetime(const local_datetime& ld)
-        : date(ld.date), time(ld.time), offset(get_local_offset())
+        : date(ld.date), time(ld.time), offset(get_local_offset(nullptr))
+          // use the current local timezone offset
    {}
    explicit offset_datetime(const std::chrono::system_clock::time_point& tp)
-        : offset_datetime(local_datetime(tp))
-    {}
+        : offset(0, 0) // use gmtime
+    {
+        const auto timet = std::chrono::system_clock::to_time_t(tp);
+        const auto tm    = detail::gmtime_s(&timet);
+        this->date = local_date(tm);
+        this->time = local_time(tm);
+    }
    explicit offset_datetime(const std::time_t& t)
-        : offset_datetime(local_datetime(t))
-    {}
+        : offset(0, 0) // use gmtime
+    {
+        const auto tm    = detail::gmtime_s(&t);
+        this->date = local_date(tm);
+        this->time = local_time(tm);
+    }
    explicit offset_datetime(const std::tm& t)
-        : offset_datetime(local_datetime(t))
-    {}
+        : offset(0, 0) // assume gmtime
+    {
+        this->date = local_date(t);
+        this->time = local_time(t);
+    }

    operator std::chrono::system_clock::time_point() const
    {
        // get date-time
        using internal_duration =
            typename std::chrono::system_clock::time_point::duration;
-        std::chrono::system_clock::time_point tp =
-            std::chrono::system_clock::time_point(this->date) +
-            std::chrono::duration_cast<internal_duration>(
-                   std::chrono::nanoseconds(this->time));

-        // get date-time in UTC. let's say we are in +09:00 (JPN).
-        // writing 12:00:00 in +09:00 means 03:00:00Z. to represent
-        // 12:00:00Z, first we need to add +09:00.
-        const auto ofs = get_local_offset();
+        // first, convert it to local date-time information in the same way as
+        // local_datetime does. later we will use time_t to adjust time offset.
+        std::tm t;
+        t.tm_sec   = static_cast<int>(this->time.second);
+        t.tm_min   = static_cast<int>(this->time.minute);
+        t.tm_hour  = static_cast<int>(this->time.hour);
+        t.tm_mday  = static_cast<int>(this->date.day);
+        t.tm_mon   = static_cast<int>(this->date.month);
+        t.tm_year  = static_cast<int>(this->date.year) - 1900;
+        t.tm_wday  = 0; // the value will be ignored
+        t.tm_yday  = 0; // the value will be ignored
+        t.tm_isdst = -1;
+        const std::time_t tp_loc = std::mktime(std::addressof(t));
+
+        auto tp = std::chrono::system_clock::from_time_t(tp_loc);
+        tp += std::chrono::duration_cast<internal_duration>(
+                std::chrono::milliseconds(this->time.millisecond) +
+                std::chrono::microseconds(this->time.microsecond) +
+                std::chrono::nanoseconds (this->time.nanosecond));
+
+        // Since mktime uses local time zone, it should be corrected.
+        // `12:00:00+09:00` means `03:00:00Z`. So mktime returns `03:00:00Z` if
+        // we are in `+09:00` timezone. To represent `12:00:00Z` there, we need
+        // to add `+09:00` to `03:00:00Z`.
+        //    Here, it uses the time_t converted from date-time info to handle
+        // daylight saving time.
+        const auto ofs = get_local_offset(std::addressof(tp_loc));
        tp += std::chrono::hours  (ofs.hour);
        tp += std::chrono::minutes(ofs.minute);

-        // here, tp represents 12:00:00 in UTC but we have offset information.
-        // we need to subtract it. For example, let's say the input is
-        // 12:00:00-08:00. now we have tp = 12:00:00Z as a result of the above
-        // conversion. But the actual time we need to return is 20:00:00Z
-        // because of -08:00.
+        // We got `12:00:00Z` by correcting local timezone applied by mktime.
+        // Then we will apply the offset. Let's say `12:00:00-08:00` is given.
+        // And now, we have `12:00:00Z`. `12:00:00-08:00` means `20:00:00Z`.
+        // So we need to subtract the offset.
        tp -= std::chrono::minutes(this->offset);
        return tp;
    }
@@ -500,11 +572,10 @@ struct offset_datetime

  private:

-    static time_offset get_local_offset()
+    static time_offset get_local_offset(const std::time_t* tp)
    {
-         // get current timezone
-        const auto tmp1 = std::time(nullptr);
-        const auto t    = detail::localtime_s(&tmp1);
+        // get local timezone with the same date-time information as mktime
+        const auto t = detail::localtime_s(tp);

        std::array<char, 6> buf;
        const auto result = std::strftime(buf.data(), 6, "%z", &t); // +hhmm\0
--- a/toml/exception.hpp
+++ b/toml/exception.hpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT License.
 #ifndef TOML11_EXCEPTION_HPP
 #define TOML11_EXCEPTION_HPP
+#include "source_location.hpp"
 #include <stdexcept>
 #include <string>

@@ -11,15 +12,21 @@ namespace toml
 struct exception : public std::exception
 {
  public:
+    exception(const source_location& loc): loc_(loc) {}
    virtual ~exception() noexcept override = default;
    virtual const char* what() const noexcept override {return "";}
+    virtual source_location const& location() const noexcept {return loc_;}
+
+  protected:
+    source_location loc_;
 };

 struct syntax_error : public toml::exception
 {
  public:
-    explicit syntax_error(const std::string& what_arg) : what_(what_arg){}
-    explicit syntax_error(const char* what_arg)        : what_(what_arg){}
+    explicit syntax_error(const std::string& what_arg, const source_location& loc)
+        : exception(loc), what_(what_arg)
+    {}
    virtual ~syntax_error() noexcept override = default;
    virtual const char* what() const noexcept override {return what_.c_str();}

@@ -30,8 +37,9 @@ struct syntax_error : public toml::exception
 struct type_error : public toml::exception
 {
  public:
-    explicit type_error(const std::string& what_arg) : what_(what_arg){}
-    explicit type_error(const char* what_arg)        : what_(what_arg){}
+    explicit type_error(const std::string& what_arg, const source_location& loc)
+        : exception(loc), what_(what_arg)
+    {}
    virtual ~type_error() noexcept override = default;
    virtual const char* what() const noexcept override {return what_.c_str();}

@@ -42,10 +50,12 @@ struct type_error : public toml::exception
 struct internal_error : public toml::exception
 {
  public:
-    explicit internal_error(const std::string& what_arg) : what_(what_arg){}
-    explicit internal_error(const char* what_arg)        : what_(what_arg){}
+    explicit internal_error(const std::string& what_arg, const source_location& loc)
+        : exception(loc), what_(what_arg)
+    {}
    virtual ~internal_error() noexcept override = default;
    virtual const char* what() const noexcept override {return what_.c_str();}
+
  protected:
    std::string what_;
 };
--- a/toml/get.hpp
+++ b/toml/get.hpp
@@ -31,10 +31,10 @@ get(const basic_value<C, M, V>& v)

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T> &&
+detail::enable_if_t<detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>
 get(basic_value<C, M, V>&& v)
 {
-    return std::move(v).template cast<detail::type_to_enum<T, basic_value<C, M, V>>::value>();
+    return T(std::move(v).template cast<detail::type_to_enum<T, basic_value<C, M, V>>::value>());
 }

 // ============================================================================
@@ -58,10 +58,10 @@ get(const basic_value<C, M, V>& v)

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-inline detail::enable_if_t<std::is_same<T, basic_value<C, M, V>>::value, T> &&
+inline detail::enable_if_t<std::is_same<T, basic_value<C, M, V>>::value, T>
 get(basic_value<C, M, V>&& v)
 {
-    return std::move(v);
+    return basic_value<C, M, V>(std::move(v));
 }

 // ============================================================================
@@ -90,7 +90,7 @@ inline detail::enable_if_t<detail::conjunction<
    >::value, T>
 get(const basic_value<C, M, V>& v)
 {
-    return static_cast<T>(v.template cast<value_t::integer>());
+    return static_cast<T>(v.as_integer());
 }

 // ============================================================================
@@ -105,7 +105,7 @@ inline detail::enable_if_t<detail::conjunction<
    >::value, T>
 get(const basic_value<C, M, V>& v)
 {
-    return static_cast<T>(v.template cast<value_t::floating>());
+    return static_cast<T>(v.as_floating());
 }

 // ============================================================================
@@ -117,7 +117,7 @@ template<typename T, typename C,
 inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string>&
 get(basic_value<C, M, V>& v)
 {
-    return v.template cast<value_t::string>().str;
+    return v.as_string().str;
 }

 template<typename T, typename C,
@@ -125,15 +125,15 @@ template<typename T, typename C,
 inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string> const&
 get(const basic_value<C, M, V>& v)
 {
-    return v.template cast<value_t::string>().str;
+    return v.as_string().str;
 }

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string> const&
+inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string>
 get(basic_value<C, M, V>&& v)
 {
-    return std::move(v.template cast<value_t::string>().str);
+    return std::string(std::move(v.as_string().str));
 }

 // ============================================================================
@@ -145,7 +145,7 @@ template<typename T, typename C,
 inline detail::enable_if_t<std::is_same<T, std::string_view>::value, std::string_view>
 get(const basic_value<C, M, V>& v)
 {
-    return std::string_view(v.template cast<value_t::string>().str);
+    return std::string_view(v.as_string().str);
 }
 #endif

@@ -158,7 +158,7 @@ inline detail::enable_if_t<detail::is_chrono_duration<T>::value, T>
 get(const basic_value<C, M, V>& v)
 {
    return std::chrono::duration_cast<T>(
-            std::chrono::nanoseconds(v.template cast<value_t::local_time>()));
+            std::chrono::nanoseconds(v.as_local_time()));
 }

 // ============================================================================
@@ -174,26 +174,23 @@ get(const basic_value<C, M, V>& v)
    {
        case value_t::local_date:
        {
-            return std::chrono::system_clock::time_point(
-                    v.template cast<value_t::local_date>());
+            return std::chrono::system_clock::time_point(v.as_local_date());
        }
        case value_t::local_datetime:
        {
-            return std::chrono::system_clock::time_point(
-                    v.template cast<value_t::local_datetime>());
+            return std::chrono::system_clock::time_point(v.as_local_datetime());
        }
        case value_t::offset_datetime:
        {
-            return std::chrono::system_clock::time_point(
-                    v.template cast<value_t::offset_datetime>());
+            return std::chrono::system_clock::time_point(v.as_offset_datetime());
        }
        default:
        {
-            throw type_error(detail::format_underline("[error] toml::value "
+            throw type_error(detail::format_underline("toml::value: "
                "bad_cast to std::chrono::system_clock::time_point", {
                    {std::addressof(detail::get_region(v)),
                     concat_to_string("the actual type is ", v.type())}
-                }));
+                }), v.location());
        }
    }
 }
@@ -259,7 +256,7 @@ get(const basic_value<C, M, V>&);
 // toml::from<T>::from_toml(v)
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V,
-         std::size_t S = sizeof(::toml::into<T>)>
+         std::size_t S = sizeof(::toml::from<T>)>
 T get(const basic_value<C, M, V>&);

 // ============================================================================
@@ -276,7 +273,7 @@ detail::enable_if_t<detail::conjunction<
 get(const basic_value<C, M, V>& v)
 {
    using value_type = typename T::value_type;
-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();
    T container;
    container.resize(ar.size());
    std::transform(ar.cbegin(), ar.cend(), container.begin(),
@@ -298,13 +295,13 @@ detail::enable_if_t<detail::conjunction<
 get(const basic_value<C, M, V>& v)
 {
    using value_type = typename T::value_type;
-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();

    T container;
    if(ar.size() != container.size())
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[erorr] toml::get specified container size is ", container.size(),
+            "toml::get: specified container size is ", container.size(),
            " but there are ", ar.size(), " elements in toml array."), {
                {std::addressof(detail::get_region(v)), "here"}
            }));
@@ -325,11 +322,11 @@ get(const basic_value<C, M, V>& v)
    using first_type  = typename T::first_type;
    using second_type = typename T::second_type;

-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();
    if(ar.size() != 2)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[erorr] toml::get specified std::pair but there are ", ar.size(),
+            "toml::get: specified std::pair but there are ", ar.size(),
            " elements in toml array."), {
                {std::addressof(detail::get_region(v)), "here"}
            }));
@@ -356,12 +353,12 @@ template<typename T, typename C,
 detail::enable_if_t<detail::is_std_tuple<T>::value, T>
 get(const basic_value<C, M, V>& v)
 {
-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();
    if(ar.size() != std::tuple_size<T>::value)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[erorr] toml::get specified std::tuple with ",
-            std::tuple_size<T>::value, "elements, but there are ", ar.size(),
+            "toml::get: specified std::tuple with ",
+            std::tuple_size<T>::value, " elements, but there are ", ar.size(),
            " elements in toml array."), {
                {std::addressof(detail::get_region(v)), "here"}
            }));
@@ -388,7 +385,7 @@ get(const basic_value<C, M, V>& v)
                  "toml::get only supports map type of which key_type is "
                  "convertible from std::string.");
    T map;
-    for(const auto& kv : v.template cast<value_t::table>())
+    for(const auto& kv : v.as_table())
    {
        map[key_type(kv.first)] = ::toml::get<mapped_type>(kv.second);
    }
@@ -421,7 +418,7 @@ T get(const basic_value<C, M, V>& v)
 }

 // ============================================================================
-// find and get
+// find

 // ----------------------------------------------------------------------------
 // these overloads do not require to set T. and returns value itself.
@@ -429,11 +426,11 @@ template<typename C,
         template<typename ...> class M, template<typename ...> class V>
 basic_value<C, M, V> const& find(const basic_value<C, M, V>& v, const key& ky)
 {
-    const auto& tab = v.template cast<value_t::table>();
+    const auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -443,11 +440,11 @@ template<typename C,
         template<typename ...> class M, template<typename ...> class V>
 basic_value<C, M, V>& find(basic_value<C, M, V>& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -455,17 +452,17 @@ basic_value<C, M, V>& find(basic_value<C, M, V>& v, const key& ky)
 }
 template<typename C,
         template<typename ...> class M, template<typename ...> class V>
-basic_value<C, M, V>&& find(basic_value<C, M, V>&& v, const key& ky)
+basic_value<C, M, V> find(basic_value<C, M, V>&& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
-    return std::move(tab.at(ky));
+    return basic_value<C, M, V>(std::move(tab.at(ky)));
 }

 // ----------------------------------------------------------------------------
@@ -476,11 +473,11 @@ template<typename T, typename C,
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V> const&>()))
 find(const basic_value<C, M, V>& v, const key& ky)
 {
-    const auto& tab = v.template cast<value_t::table>();
+    const auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -492,11 +489,11 @@ template<typename T, typename C,
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&>()))
 find(basic_value<C, M, V>& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -508,11 +505,11 @@ template<typename T, typename C,
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&&>()))
 find(basic_value<C, M, V>&& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -541,7 +538,7 @@ find(basic_value<C, M, V>& v, const ::toml::key& ky, Ts&& ... keys)
 template<typename C,
         template<typename ...> class M, template<typename ...> class V,
         typename ... Ts>
-basic_value<C, M, V>&&
+basic_value<C, M, V>
 find(basic_value<C, M, V>&& v, const ::toml::key& ky, Ts&& ... keys)
 {
    return ::toml::find(::toml::find(std::move(v), ky), std::forward<Ts>(keys)...);
@@ -575,6 +572,28 @@ find(basic_value<C, M, V>&& v, const ::toml::key& ky, Ts&& ... keys)
 // ============================================================================
 // get_or(value, fallback)

+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V> const&
+get_or(const basic_value<C, M, V>& v, const basic_value<C, M, V>&)
+{
+    return v;
+}
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>&
+get_or(basic_value<C, M, V>& v, basic_value<C, M, V>&)
+{
+    return v;
+}
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>
+get_or(basic_value<C, M, V>&& v, basic_value<C, M, V>&&)
+{
+    return v;
+}
+
 // ----------------------------------------------------------------------------
 // specialization for the exact toml types (return type becomes lvalue ref)

@@ -586,8 +605,7 @@ get_or(const basic_value<C, M, V>& v, const T& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(v);
    }
    catch(...)
    {
@@ -602,8 +620,7 @@ get_or(basic_value<C, M, V>& v, T& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(v);
    }
    catch(...)
    {
@@ -612,18 +629,17 @@ get_or(basic_value<C, M, V>& v, T& opt)
 }
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<
-    detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>&&
+detail::enable_if_t<detail::is_exact_toml_type<detail::remove_cvref_t<T>,
+    basic_value<C, M, V>>::value, detail::remove_cvref_t<T>>
 get_or(basic_value<C, M, V>&& v, T&& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(std::move(v));
    }
    catch(...)
    {
-        return opt;
+        return detail::remove_cvref_t<T>(std::forward<T>(opt));
    }
 }

@@ -632,14 +648,13 @@ get_or(basic_value<C, M, V>&& v, T&& opt)

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<std::is_same<
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type,
-    std::string>::value, std::string> const&
-get_or(const basic_value<C, M, V>& v, T&& opt)
+detail::enable_if_t<std::is_same<detail::remove_cvref_t<T>, std::string>::value,
+    std::string> const&
+get_or(const basic_value<C, M, V>& v, const T& opt)
 {
    try
    {
-        return v.template cast<value_t::string>().str;
+        return v.as_string().str;
    }
    catch(...)
    {
@@ -653,7 +668,7 @@ get_or(basic_value<C, M, V>& v, T& opt)
 {
    try
    {
-        return v.template cast<value_t::string>().str;
+        return v.as_string().str;
    }
    catch(...)
    {
@@ -662,18 +677,17 @@ get_or(basic_value<C, M, V>& v, T& opt)
 }
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<std::is_same<
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type,
-    std::string>::value, std::string>
+detail::enable_if_t<
+    std::is_same<detail::remove_cvref_t<T>, std::string>::value, std::string>
 get_or(basic_value<C, M, V>&& v, T&& opt)
 {
    try
    {
-        return std::move(v.template cast<value_t::string>().str);
+        return std::move(v.as_string().str);
    }
    catch(...)
    {
-        return std::forward<T>(opt);
+        return std::string(std::forward<T>(opt));
    }
 }

@@ -688,11 +702,11 @@ get_or(const basic_value<C, M, V>& v, T&& opt)
 {
    try
    {
-        return std::move(v.template cast<value_t::string>().str);
+        return std::move(v.as_string().str);
    }
    catch(...)
    {
-        return std::string(opt);
+        return std::string(std::forward<T>(opt));
    }
 }

@@ -702,30 +716,61 @@ get_or(const basic_value<C, M, V>& v, T&& opt)
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
-    detail::negation<detail::is_exact_toml_type<
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type,
+    detail::negation<detail::is_exact_toml_type<detail::remove_cvref_t<T>,
        basic_value<C, M, V>>>,
-    detail::negation<std::is_same<std::string,
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type>>,
+    detail::negation<std::is_same<std::string, detail::remove_cvref_t<T>>>,
    detail::negation<detail::is_string_literal<
        typename std::remove_reference<T>::type>>
-    >::value, typename std::remove_reference<T>::type>
+    >::value, detail::remove_cvref_t<T>>
 get_or(const basic_value<C, M, V>& v, T&& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(v);
    }
    catch(...)
    {
-        return std::forward<T>(opt);
+        return detail::remove_cvref_t<T>(std::forward<T>(opt));
    }
 }

 // ===========================================================================
 // find_or(value, key, fallback)

+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V> const&
+find_or(const basic_value<C, M, V>& v, const key& ky,
+        const basic_value<C, M, V>& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = v.as_table();
+    if(tab.count(ky) == 0) {return opt;}
+    return tab.at(ky);
+}
+
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>&
+find_or(basic_value<C, M, V>& v, const toml::key& ky, basic_value<C, M, V>& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto& tab = v.as_table();
+    if(tab.count(ky) == 0) {return opt;}
+    return tab.at(ky);
+}
+
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>
+find_or(basic_value<C, M, V>&& v, const toml::key& ky, basic_value<C, M, V>&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto tab = std::move(v).as_table();
+    if(tab.count(ky) == 0) {return opt;}
+    return basic_value<C, M, V>(std::move(tab.at(ky)));
+}
+
 // ---------------------------------------------------------------------------
 // exact types (return type can be a reference)
 template<typename T, typename C,
@@ -749,19 +794,20 @@ find_or(basic_value<C, M, V>& v, const toml::key& ky, T& opt)
    if(!v.is_table()) {return opt;}
    auto& tab = v.as_table();
    if(tab.count(ky) == 0) {return opt;}
-    return get_or(tab[ky], opt);
+    return get_or(tab.at(ky), opt);
 }

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<
-    detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>&&
+    detail::is_exact_toml_type<T, basic_value<C, M, V>>::value,
+    detail::remove_cvref_t<T>>
 find_or(basic_value<C, M, V>&& v, const toml::key& ky, T&& opt)
 {
-    if(!v.is_table()) {return opt;}
+    if(!v.is_table()) {return std::forward<T>(opt);}
    auto tab = std::move(v).as_table();
-    if(tab.count(ky) == 0) {return opt;}
-    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    return get_or(std::move(tab.at(ky)), std::forward<T>(opt));
 }

 // ---------------------------------------------------------------------------
@@ -807,7 +853,7 @@ detail::enable_if_t<
    std::string>
 find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
 {
-    if(!v.is_table()) {return opt;}
+    if(!v.is_table()) {return std::string(opt);}
    const auto& tab = v.as_table();
    if(tab.count(ky) == 0) {return std::string(opt);}
    return get_or(tab.at(ky), std::forward<T>(opt));
@@ -818,19 +864,20 @@ find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
+    // T is not an exact toml type
    detail::negation<detail::is_exact_toml_type<
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type,
-        basic_value<C, M, V>>>,
-    detail::negation<std::is_same<std::string,
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type>>,
+        detail::remove_cvref_t<T>, basic_value<C, M, V>>>,
+    // T is not std::string
+    detail::negation<std::is_same<std::string, detail::remove_cvref_t<T>>>,
+    // T is not a string literal
    detail::negation<detail::is_string_literal<
        typename std::remove_reference<T>::type>>
-    >::value, T>
+    >::value, detail::remove_cvref_t<T>>
 find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
 {
-    if(!v.is_table()) {return opt;}
+    if(!v.is_table()) {return std::forward<T>(opt);}
    const auto& tab = v.as_table();
-    if(tab.count(ky) == 0) {return opt;}
+    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
    return get_or(tab.at(ky), std::forward<T>(opt));
 }

@@ -864,21 +911,6 @@ expect(const basic_value<C, M, V>& v, const toml::key& k) noexcept
        return err(e.what());
    }
 }
-template<typename T, typename Table>
-detail::enable_if_t<detail::conjunction<
-    detail::is_map<Table>, detail::is_basic_value<typename Table::mapped_type>
-    >::value, result<T, std::string>>
-expect(const Table& t, const toml::key& k,
-       std::string tablename = "unknown table") noexcept
-{
-    try
-    {
-        return ok(find<T>(t, k, std::move(tablename)));
-    }
-    catch(const std::exception& e)
-    {
-        return err(e.what());
-    }
-}
+
 } // toml
 #endif// TOML11_GET
--- a/toml/lexer.hpp
+++ b/toml/lexer.hpp
@@ -63,12 +63,22 @@ using lex_integer = either<lex_bin_int, lex_oct_int, lex_hex_int, lex_dec_int>;
 using lex_inf = sequence<character<'i'>, character<'n'>, character<'f'>>;
 using lex_nan = sequence<character<'n'>, character<'a'>, character<'n'>>;
 using lex_special_float = sequence<maybe<lex_sign>, either<lex_inf, lex_nan>>;
-using lex_exponent_part = sequence<either<character<'e'>, character<'E'>>, lex_dec_int>;

 using lex_zero_prefixable_int = sequence<lex_digit, repeat<either<lex_digit,
-      sequence<lex_underscore, lex_digit>>, unlimited>>;
+    sequence<lex_underscore, lex_digit>>, unlimited>>;
+
 using lex_fractional_part = sequence<character<'.'>, lex_zero_prefixable_int>;

+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+// use toml-lang/toml HEAD
+using lex_exponent_part   = sequence<either<character<'e'>, character<'E'>>,
+        maybe<lex_sign>, lex_zero_prefixable_int>;
+#else
+// strictly TOML v0.5.0
+using lex_exponent_part = sequence<either<character<'e'>, character<'E'>>,
+        lex_dec_int>;
+#endif
+
 using lex_float = either<lex_special_float,
      sequence<lex_dec_int, either<lex_exponent_part,
      sequence<lex_fractional_part, maybe<lex_exponent_part>>>>>;
@@ -115,9 +125,17 @@ using lex_local_time       = lex_partial_time;
 // ===========================================================================

 using lex_quotation_mark  = character<'"'>;
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+using lex_basic_unescaped = exclude<either<in_range<0x00, 0x08>, // 0x09 (tab)
+                                           in_range<0x0a, 0x1F>, // is allowed
+                                           character<0x22>, character<0x5C>,
+                                           character<0x7F>>>;
+#else
 using lex_basic_unescaped = exclude<either<in_range<0x00, 0x1F>,
                                           character<0x22>, character<0x5C>,
                                           character<0x7F>>>;
+
+#endif
 using lex_escape          = character<'\\'>;
 using lex_escape_unicode_short = sequence<character<'u'>,
                                          repeat<lex_hex_dig, exactly<4>>>;
@@ -137,10 +155,18 @@ using lex_basic_string = sequence<lex_quotation_mark,
                                  lex_quotation_mark>;

 using lex_ml_basic_string_delim = repeat<lex_quotation_mark, exactly<3>>;
-using lex_ml_basic_unescaped    = exclude<either<in_range<0x00, 0x1F>,
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+using lex_ml_basic_unescaped    = exclude<either<in_range<0x00, 0x08>, // 0x09
+                                                 in_range<0x0a, 0x1F>, // is tab
                                                 character<0x5C>,
                                                 character<0x7F>,
                                                 lex_ml_basic_string_delim>>;
+#else // TOML v0.5.0
+using lex_ml_basic_unescaped    = exclude<either<in_range<0x00,0x1F>,
+                                                 character<0x5C>,
+                                                 character<0x7F>,
+                                                 lex_ml_basic_string_delim>>;
+#endif

 using lex_ml_basic_escaped_newline = sequence<
        lex_escape, maybe<lex_ws>, lex_newline,
--- a/toml/literal.hpp
+++ b/toml/literal.hpp
@@ -76,7 +76,8 @@ inline ::toml::value operator"" _toml(const char* str, std::size_t len)
    }
    else // none of them.
    {
-        throw ::toml::syntax_error(data.unwrap_err());
+        throw ::toml::syntax_error(data.unwrap_err(),
+                                   source_location(std::addressof(loc)));
    }
 }

--- a/toml/parser.hpp
+++ b/toml/parser.hpp
--- a/toml/region.hpp
+++ b/toml/region.hpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT License.
 #ifndef TOML11_REGION_HPP
 #define TOML11_REGION_HPP
-#include "exception.hpp"
 #include <memory>
 #include <vector>
 #include <algorithm>
@@ -10,6 +9,7 @@
 #include <iterator>
 #include <iomanip>
 #include <cassert>
+#include "color.hpp"

 namespace toml
 {
@@ -231,11 +231,10 @@ struct region final : public region_base

    region& operator+=(const region& other)
    {
-        if(this->begin() != other.begin() || this->end() != other.end() ||
-           this->last_  != other.first_)
-        {
-            throw internal_error("invalid region concatenation");
-        }
+        // different regions cannot be concatenated
+        assert(this->begin() == other.begin() && this->end() == other.end() &&
+               this->last_   == other.first_);
+
        this->last_ = other.last_;
        return *this;
    }
@@ -420,7 +419,8 @@ struct region final : public region_base
 // to show a better error message.
 inline std::string format_underline(const std::string& message,
        const std::vector<std::pair<region_base const*, std::string>>& reg_com,
-        const std::vector<std::string>& helps = {})
+        const std::vector<std::string>& helps = {},
+        const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
 {
    assert(!reg_com.empty());

@@ -434,7 +434,27 @@ inline std::string format_underline(const std::string& message,
    )->first->line_num().size());

    std::ostringstream retval;
-    retval << message << '\n';
+
+    if(colorize)
+    {
+        retval << color::colorize; // turn on ANSI color
+    }
+
+    // XXX
+    // Here, before `colorize` support, it does not output `[error]` prefix
+    // automatically. So some user may output it manually and this change may
+    // duplicate the prefix. To avoid it, check the first 7 characters and
+    // if it is "[error]", it removes that part from the message shown.
+    if(message.size() > 7 && message.substr(0, 7) == "[error]")
+    {
+        retval << color::bold << color::red << "[error]" << color::reset
+               << color::bold << message.substr(7) << color::reset << '\n';
+    }
+    else
+    {
+        retval << color::bold << color::red << "[error] " << color::reset
+               << color::bold << message << color::reset << '\n';
+    }

    for(auto iter = reg_com.begin(); iter != reg_com.end(); ++iter)
    {
@@ -442,34 +462,41 @@ inline std::string format_underline(const std::string& message,
        if(iter != reg_com.begin() &&
           std::prev(iter)->first->name() == iter->first->name())
        {
-            retval << "\n ...\n";
+            retval << color::bold << color::blue << "\n ...\n" << color::reset;
        }
        else // if filename differs, print " --> filename.toml"
        {
            if(iter != reg_com.begin()) {retval << '\n';}
-            retval << " --> " << iter->first->name() << '\n';
+            retval << color::bold << color::blue << " --> " << color::reset
+                   << iter->first->name() << '\n';
+            // add one almost-empty line for readability
+            retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ')
+                   << color::bold << color::blue << " | "  << color::reset << '\n';
        }
        const region_base* const reg = iter->first;
        const std::string&   comment = iter->second;

-        retval << ' ' << std::setw(line_num_width) << reg->line_num();
-        retval << " | " << reg->line() << '\n';
-        retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ');
-        retval << " | " << make_string(reg->before(), ' ');
+        retval << ' ' << std::setw(line_num_width) << color::bold << color::blue
+               << reg->line_num() << " | "  << color::reset << reg->line() << '\n';
+
+        retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ')
+               << color::bold << color::blue << " | " << color::reset
+               << make_string(reg->before(), ' ');

        if(reg->size() == 1)
        {
            // invalid
            // ^------
-            retval << '^';
-            retval << make_string(reg->after(), '-');
+            retval << color::bold << color::red
+                   << '^' << make_string(reg->after(), '-') << color::reset;
        }
        else
        {
            // invalid
            // ~~~~~~~
            const auto underline_len = std::min(reg->size(), reg->line().size());
-            retval << make_string(underline_len, '~');
+            retval << color::bold << color::red
+                   << make_string(underline_len, '~') << color::reset;
        }
        retval << ' ';
        retval << comment;
@@ -479,10 +506,10 @@ inline std::string format_underline(const std::string& message,
    {
        retval << '\n';
        retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ');
-        retval << " | ";
+        retval << color::bold << color::blue << " | " << color::reset;
        for(const auto help : helps)
        {
-            retval << "\nHint: ";
+            retval << color::bold << "\nHint: " << color::reset;
            retval << help;
        }
    }
--- a/toml/serializer.hpp
+++ b/toml/serializer.hpp
@@ -118,8 +118,14 @@ struct serializer
        {
            return token; // there is no exponent part. just return it.
        }
-
-        // zero-prefix in an exponent is NOT allowed in TOML.
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+        // Although currently it is not released yet, TOML will allow
+        // zero-prefix in an exponent part such as 1.234e+01.
+        // The following code removes the zero prefixes.
+        // If the feature is activated, the following codes can be skipped.
+        return token;
+#endif
+        // zero-prefix in an exponent is NOT allowed in TOML v0.5.0.
        // remove it if it exists.
        bool        sign_exists = false;
        std::size_t zero_prefix = 0;
--- a/toml/source_location.hpp
+++ b/toml/source_location.hpp
@@ -48,7 +48,11 @@ struct source_location
    {
        if(reg)
        {
-            line_num_    = static_cast<std::uint_least32_t>(std::stoul(reg->line_num()));
+            if(reg->line_num() != detail::region_base().line_num())
+            {
+                line_num_ = static_cast<std::uint_least32_t>(
+                        std::stoul(reg->line_num()));
+            }
            column_num_  = static_cast<std::uint_least32_t>(reg->before() + 1);
            region_size_ = static_cast<std::uint_least32_t>(reg->size());
            file_name_   = reg->name();
--- a/toml/string.hpp
+++ b/toml/string.hpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT License.
 #ifndef TOML11_STRING_HPP
 #define TOML11_STRING_HPP
+#include <algorithm>
 #include <string>
 #include <cstdint>
 #if __cplusplus >= 201703L
@@ -45,6 +46,11 @@ struct string
    operator std::string const& () const& noexcept {return str;}
    operator std::string&&      () &&     noexcept {return std::move(str);}

+    string& operator+=(const char*        rhs) {str += rhs; return *this;}
+    string& operator+=(const char         rhs) {str += rhs; return *this;}
+    string& operator+=(const std::string& rhs) {str += rhs; return *this;}
+    string& operator+=(const string&      rhs) {str += rhs.str; return *this;}
+
 #if __cplusplus >= 201703L
    explicit string(std::string_view s): kind(string_t::basic), str(s){}
    string(std::string_view s, string_t k): kind(k), str(s){}
@@ -54,6 +60,8 @@ struct string

    explicit operator std::string_view() const noexcept
    {return std::string_view(str);}
+
+    string& operator+=(const std::string_view& rhs) {str += rhs; return *this;}
 #endif

    string_t    kind;
--- a/toml/traits.hpp
+++ b/toml/traits.hpp
@@ -105,7 +105,7 @@ struct has_into_toml_method
 : decltype(has_into_toml_method_impl::check<T>(nullptr)){};

 #ifdef __INTEL_COMPILER
-#undef decltype(...)
+#undef decltype
 #endif

 // ---------------------------------------------------------------------------
@@ -240,6 +240,19 @@ disjunction<
        >
    >{};

+// ---------------------------------------------------------------------------
+// C++20 remove_cvref_t
+
+template<typename T>
+struct remove_cvref
+{
+    using type = typename std::remove_cv<
+        typename std::remove_reference<T>::type>::type;
+};
+
+template<typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
+
 }// detail
 }//toml
 #endif // TOML_TRAITS
--- a/toml/value.hpp
+++ b/toml/value.hpp
@@ -32,10 +32,10 @@ template<value_t Expected,
 throw_bad_cast(value_t actual, const ::toml::basic_value<C, T, A>& v)
 {
    throw type_error(detail::format_underline(concat_to_string(
-        "[error] toml::value bad_cast to ", Expected), {
+        "toml::value: bad_cast to ", Expected), {
            {std::addressof(get_region(v)),
             concat_to_string("the actual type is ", actual)}
-        }));
+        }), v.location());
 }

 // switch by `value_t` and call the corresponding `value::as_xxx()`. {{{
@@ -1567,6 +1567,45 @@ class basic_value
        return std::move(this->table_.value());
    }

+    // accessors =============================================================
+    //
+    // may throw type_error or out_of_range
+    //
+    value_type&       at(const key& k)
+    {
+        return this->as_table().at(k);
+    }
+    value_type const& at(const key& k) const
+    {
+        return this->as_table().at(k);
+    }
+    value_type&       operator[](const key& k)
+    {
+        if(this->is_uninitialized())
+        {
+            *this = table_type{};
+        }
+        return this->as_table()[k];
+    }
+
+    value_type&       at(const std::size_t idx)
+    {
+        return this->as_array().at(idx);
+    }
+    value_type const& at(const std::size_t idx) const
+    {
+        return this->as_array().at(idx);
+    }
+
+    value_type&       operator[](const std::size_t idx) noexcept
+    {
+        return this->as_array(std::nothrow)[idx];
+    }
+    value_type const& operator[](const std::size_t idx) const noexcept
+    {
+        return this->as_array(std::nothrow)[idx];
+    }
+
    source_location location() const
    {
        return source_location(this->region_info_.get());
@@ -1821,25 +1860,27 @@ operator>=(const basic_value<C, T, A>& lhs, const basic_value<C, T, A>& rhs)
 template<typename C, template<typename ...> class T, template<typename ...> class A>
 inline std::string format_error(const std::string& err_msg,
        const basic_value<C, T, A>& v, const std::string& comment,
-        std::vector<std::string> hints = {})
+        std::vector<std::string> hints = {},
+        const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
 {
    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));
+        }, std::move(hints), colorize);
 }

 template<typename C, template<typename ...> class T, template<typename ...> class A>
 inline std::string format_error(const std::string& err_msg,
        const toml::basic_value<C, T, A>& v1, const std::string& comment1,
        const toml::basic_value<C, T, A>& v2, const std::string& comment2,
-        std::vector<std::string> hints = {})
+        std::vector<std::string> hints = {},
+        const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
 {
    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));
+        }, std::move(hints), colorize);
 }

 template<typename C, template<typename ...> class T, template<typename ...> class A>
@@ -1847,14 +1888,15 @@ inline std::string format_error(const std::string& err_msg,
        const toml::basic_value<C, T, A>& v1, const std::string& comment1,
        const toml::basic_value<C, T, A>& v2, const std::string& comment2,
        const toml::basic_value<C, T, A>& v3, const std::string& comment3,
-        std::vector<std::string> hints = {})
+        std::vector<std::string> hints = {},
+        const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
 {
    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));
+        }, std::move(hints), colorize);
 }

 template<typename Visitor, typename C,
Author	SHA1	Message	Date
ToruNiina	8567f09cbf	chore: update version info in CMake	2019-12-13 20:25:52 +09:00
ToruNiina	a6d24b02d5	Merge branch 'colorize-err-msg'	2019-12-13 20:23:27 +09:00
ToruNiina	08bf5ffbdf	doc: put screenshot to colorize-error-message	2019-12-13 17:28:43 +09:00
ToruNiina	a945bd6eac	ci: pass TOML11_COLORIZE_ERROR_MESSAGE on CircleCI	2019-12-13 16:47:33 +09:00
ToruNiina	f4ac286b0f	doc: add description about format_error	2019-12-12 21:31:21 +09:00
ToruNiina	f31dc6ba37	doc: add example of hints in an error message	2019-12-12 18:09:13 +09:00
ToruNiina	fecd50dfeb	doc: add contributors	2019-12-12 18:02:16 +09:00
ToruNiina	d48d454a61	doc: modify README a bit	2019-12-12 17:55:20 +09:00
ToruNiina	4688c235f5	refactor: rename internal macro value	2019-12-12 17:38:29 +09:00
ToruNiina	5c146857a3	Merge branch 'master' into colorize-err-msg	2019-12-11 22:49:38 +09:00
ToruNiina	bc51699415	Merge branch 'bracket-operator'	2019-12-11 19:36:21 +09:00
Toru Niina	8b923d56e9	Merge pull request #96 from kenichiice/icpc_warning2 Suppress warning on Intel C++ Compiler	2019-12-11 18:30:44 +09:00
OGAWA KenIchi	3190c1da9f	fix: suppress warning on Intel C++ Compiler	2019-12-11 17:47:16 +09:00
ToruNiina	a41dc08025	doc: add document of operator[]	2019-12-10 20:06:01 +09:00
ToruNiina	0c084b3a5c	test: add test: accessing via bracket operator	2019-12-10 00:08:40 +09:00
ToruNiina	8fbeaabfd9	feat: add operator[] to access table/array	2019-12-10 00:00:05 +09:00
ToruNiina	331de4ea5d	fix: use datetime info while getting time offset to convert offset_datetime to system_clock::time_point.	2019-12-08 22:44:12 +11:00
ToruNiina	b246f5ac5c	fix: combine date and time to convert loc datetime Normally DST begins at A.M. 3 or 4. If we re-use conversion operator of local_date and local_time independently, the conversion fails if it is the day when DST begins or ends. Since local_date considers the time is 00:00 A.M. and local_time does not consider DST because it does not have any date information. We need to consider both date and time information at the same time to convert it correctly.	2019-12-08 22:38:49 +11:00
ToruNiina	89714fb24b	doc: note about local timezone and datetime	2019-12-06 21:15:31 +09:00
ToruNiina	62c01f9826	fix: consider timezone correctly explicitly set tm.tm_isdst = 0 and use UTC offset	2019-12-06 20:57:51 +09:00
ToruNiina	5a8d368927	feat: add thread-safe detail::gmtime_s	2019-12-06 20:33:15 +09:00
ToruNiina	28519f5712	doc: add colorize section to README	2019-12-02 17:08:00 +09:00
Toru Niina	63fdbd25cf	Merge pull request #95 from blockparty-sh/unused-variable-warning Suppress unused variable warning	2019-11-23 12:59:21 +09:00
blockparty	6d41a1adb9	Suppress unused variable warning	2019-11-22 05:59:55 -06:00
Toru Niina	26a09b2f65	Merge pull request #93 from blockparty-sh/fix_compile_error Check if features are defined	2019-11-21 21:57:26 +09:00
blockparty	7e62dad6dc	Check if features are defined	2019-11-21 05:51:31 -06:00
ToruNiina	2fd466a3c3	fix: skip only the prefix, keep spaces	2019-11-14 15:32:17 +09:00
ToruNiina	6f7539dc6a	fix: deduplicate [error] prefix in the messages	2019-11-14 15:31:27 +09:00
ToruNiina	f290390c63	fix: consider the no-space cases like [error]:	2019-11-13 18:14:42 +09:00
ToruNiina	571baa2c26	refactor: remove nocolor:: operations since color can be on-off at runtime	2019-11-13 18:08:31 +09:00
ToruNiina	bbe33e87d9	feat: detect [error] prefix duplication	2019-11-13 18:05:37 +09:00
ToruNiina	4c5076f263	feat: add runtime colorize flag	2019-11-13 18:01:47 +09:00
ToruNiina	d47174954f	feat: colorize user-defined msg by format_error	2019-11-13 18:00:55 +09:00
ToruNiina	821eb9632b	feat: add a macro-dependent constant	2019-11-13 17:59:47 +09:00
ToruNiina	af116991b6	fix: remove overlapping [error] sign	2019-11-13 17:35:23 +09:00
ToruNiina	87bebbc37d	feat: put color to the internal error messages	2019-11-13 17:35:05 +09:00
ToruNiina	c2d0351e69	feat: add (ANSI) terminal colorize operators	2019-11-13 17:24:51 +09:00
ToruNiina	1526b9feee	Merge branch 'heterogeneous-array'	2019-11-09 11:03:18 +09:00
ToruNiina	281206dcc6	doc: add heterogeneous array to README	2019-11-08 19:03:16 +09:00
ToruNiina	adf8fa9234	fix: fix typos in an error message in toml::get when converting toml::value to std::tuple	2019-11-08 16:12:18 +09:00
ToruNiina	0a66be3257	test: add test for parsing heterogeneous array this test case is activated only if TOML11_USE_UNRELEASED_TOML_FEATURES is defined.	2019-11-08 15:52:31 +09:00
ToruNiina	160537360c	test: deactivate error check for hetero array if TOML11_USE_UNRELEASED_TOML_FEATURES is activated.	2019-11-08 15:39:14 +09:00
ToruNiina	9af2d65417	feat: allow heterogenous array if TOML11_USE_UNRELEASED_TOML_FEATURES is activated. In TOML v0.5.0, heterogenous arrays are not allowed. But after some discussions in toml-lang/toml, it is decided to allow it in the next release (toml-lang/toml/pull/676). To support it, disable type check in parse_array function.	2019-11-08 15:36:58 +09:00
ToruNiina	429763377f	Merge branch 'add-src-loc-to-exception' #87	2019-11-02 13:42:14 +09:00
ToruNiina	c774beb79a	doc: write about source_location in exceptions	2019-11-02 13:03:50 +09:00
ToruNiina	8240fffeca	Merge branch 'master' into add-src-loc-to-exception	2019-11-02 12:53:16 +09:00
ToruNiina	047611764c	fix: silly typo	2019-11-01 21:15:20 +09:00
ToruNiina	bc3eb9d967	feat: add src_loc to all the exceptions including internal_error.	2019-11-01 21:14:33 +09:00
ToruNiina	6862264bde	feat: use the first char as the top-level region A bit related to #89	2019-11-01 20:47:25 +09:00
ToruNiina	2ee69fc420	fix: improve error messages about strings a bit	2019-11-01 13:34:15 +09:00
ToruNiina	6a15e8360f	refactor: remove redundant namespace specifier	2019-10-31 23:13:49 +09:00
ToruNiina	b4c6d26842	Merge origin/add-src-loc-to-exception #87	2019-10-31 23:11:53 +09:00
ToruNiina	41eb1d6887	feat: pass source_location to exception	2019-10-31 22:23:31 +09:00
ToruNiina	3ca712a8da	feat: check line_num before converting it to int	2019-10-31 22:21:24 +09:00
ToruNiina	8e589ff4d7	feat: add source_location to (syntax_\|type_)error	2019-10-31 22:04:16 +09:00
ToruNiina	56812114c3	refactor: simplify inclusion dependencies	2019-10-31 21:58:28 +09:00
ToruNiina	f98615d0df	fix: check file content is empty or not	2019-10-30 16:49:49 +09:00
ToruNiina	37769e28f0	fix #88 : check if input is null-terminated or not	2019-10-30 16:33:22 +09:00
ToruNiina	2acdec00aa	Merge branch 'refactor-ci'	2019-10-15 23:13:44 +09:00
ToruNiina	354cfc979a	ci: cache brew directory	2019-10-15 23:13:11 +09:00
ToruNiina	3dc3b001ff	ci: update clang 3.x from 3.7 to 3.9	2019-10-15 23:13:06 +09:00
ToruNiina	ea24a91f4c	ci: use `sourceline`	2019-10-15 20:32:09 +09:00
ToruNiina	5bba73a8ca	ci: use addons in OS X on Travis.CI	2019-10-15 20:27:27 +09:00
ToruNiina	54eced6c82	test: add test for toml::string::operator+=	2019-10-09 21:51:33 +09:00
ToruNiina	258e62f8f3	feat: add operator+= to toml::string	2019-10-09 21:51:14 +09:00
ToruNiina	06086a9ff7	doc: add note about value::at	2019-10-09 21:09:38 +09:00
ToruNiina	b4b35ea33e	feat: allow 0-prefix exponent if the flag is on If unreleased feature is activated, zero-prefixes in an exponent part of a floating point is allowed. If the flag TOML11_UNRELEASED_TOML_FEATURES is turned on, we don't need to check whether there is a zero prefix in the exponent part that is formatted by a standard library.	2019-10-08 23:23:53 +09:00
ToruNiina	d7b4d104d3	refactor: reduce checking; just check once	2019-10-08 23:15:03 +09:00
ToruNiina	e12fd4d944	doc: add contributors	2019-10-04 14:28:43 +09:00
ToruNiina	36af02cb3a	test: add test cases for one-way conversion	2019-10-04 13:01:15 +09:00
ToruNiina	488015df49	fix: toml -> T is required; related to #83	2019-10-04 13:00:34 +09:00
Toru Niina	1f951e49b1	Merge pull request #84 from jcmoyer/master Update documentation for toml::from and toml::into	2019-10-04 12:58:13 +09:00
J.C. Moyer	6a7dbb7875	Update documentation for toml::from and toml::into	2019-10-03 21:28:06 -04:00
ToruNiina	ad7eb56634	fix: avoid potential memory bugs related to move	2019-10-03 14:42:52 +09:00
ToruNiina	b01c5534ed	test: add test cases for const-ref version	2019-10-03 13:52:12 +09:00
ToruNiina	22dac3c9f2	Merge branch 'value-at'	2019-09-28 19:40:51 +09:00
ToruNiina	d5adfe8c7d	refactor: use as_xxx instead of cast<enum> because cast<enum>() requires `template` specifier inside a template function. it makes code long.	2019-09-28 17:01:45 +09:00
ToruNiina	4bb8045c84	doc: add `basic_value::at`.	2019-09-28 16:31:45 +09:00
ToruNiina	babb6ab3fe	test: add test case for basic_value::at	2019-09-28 16:22:01 +09:00
ToruNiina	d73bc6076c	feat: add basic_value::at(key) and at(idx)	2019-09-28 16:21:51 +09:00
ToruNiina	8d1da6e8b5	test: add test cases for find_or(&&) + conversion	2019-09-28 14:01:33 +09:00
ToruNiina	8276e12f06	test: add test cases for toml::find_or(value&&)	2019-09-28 13:38:59 +09:00
ToruNiina	f3d3f63ff9	fix: return values from find_or(value&&)	2019-09-28 13:38:26 +09:00
ToruNiina	d9689c878d	test: add test cases for toml::find(value&&, key)	2019-09-28 13:05:13 +09:00
ToruNiina	df097cb09a	test: add test cases of get_or(value&&, U)	2019-09-28 12:13:59 +09:00
ToruNiina	a425e3b7c6	test: add test cases of toml::get_or(value&&, T&&)	2019-09-28 12:08:14 +09:00
ToruNiina	e4b4503b81	style: add comment to test::operator<<	2019-09-28 12:07:53 +09:00
ToruNiina	b44fbad925	fix: remove needless ::type	2019-09-28 11:14:14 +09:00
ToruNiina	826c9444ac	refactor: use remove_cvref	2019-09-28 11:03:46 +09:00
ToruNiina	a1095f3e4c	refactor: use std::map::at instead of []	2019-09-28 11:03:14 +09:00
ToruNiina	483a39beb4	refactor: remove unsupported overload expect<T>(table, ...)	2019-09-28 11:00:35 +09:00
ToruNiina	1409114c96	refactor: add utility meta-func for internal use	2019-09-28 10:58:02 +09:00
ToruNiina	ecfc9d0c5a	fix: make return type rvalue when rvalue is passed	2019-09-28 10:31:10 +09:00
ToruNiina	94f76137a3	doc: add description of unreleased toml features	2019-09-05 14:31:05 +09:00
ToruNiina	c2e1aa9a3c	Merge branch 'master' into fp-exp-leading-zeroes	2019-09-05 13:50:58 +09:00
ToruNiina	5b5ece6c32	fix: add "unreleased" flag to raw-tab-in-string	2019-09-04 18:10:15 +09:00
ToruNiina	b696e327d7	ci: add options to test toml-head features	2019-09-04 13:37:08 +09:00
ToruNiina	757e5d60be	test: add flag for toml-head features to tests	2019-09-04 13:36:42 +09:00
ToruNiina	c02093de7f	chore: add an option to tests that enable/disable to use unreleased toml features	2019-09-04 13:34:28 +09:00
ToruNiina	4f8b62a7e9	feat: add TOML11_USE_UNRELEASED_TOML_FEATURES flag to choose to use unreleased toml feature	2019-09-04 13:32:05 +09:00
ToruNiina	d9b8582c47	test: add test for toml::get<T>(std::move(v))	2019-09-01 19:39:37 +09:00
ToruNiina	c9543d8d9e	test: add test of find_or with conversion	2019-08-31 13:05:05 +09:00
ToruNiina	15b68a89c6	fix: suppress warnings by forwarding argument	2019-08-31 13:04:25 +09:00
ToruNiina	64e7bdb835	test: add test for leading zeroes in fp exp	2019-08-28 17:49:12 +09:00
ToruNiina	1acf87679e	feat: permit leading 0s in exp parts of floats This is an unreleased feature of toml language, but is merged into toml-lang/toml:master.	2019-08-28 16:02:10 +09:00
ToruNiina	7a1b5bd64e	fix: skip whitespaces without newline	2019-08-26 18:16:09 +09:00
ToruNiina	e332e018db	feat: allow raw tab characters in basic strings This feature is planned to be incorporated in toml v1.0.0 but not released yet.	2019-08-21 11:19:47 +09:00
ToruNiina	b1ec6d87bd	chore: update patch version	2019-08-07 15:58:28 +09:00
ToruNiina	8dded288b4	Merge branch 'master' into find-or-value	2019-08-07 14:58:56 +09:00
ToruNiina	0f491c7f3a	fix: add overload for find_or with toml::value	2019-08-07 14:55:30 +09:00
ToruNiina	5edf43a1d2	test: add missing include file to test code	2019-07-23 22:32:32 +09:00
ToruNiina	cffc605505	fix: stop including iostream	2019-07-23 22:27:20 +09:00
ToruNiina	fb91936a1d	fix #76 : correct version description in CMakeLists	2019-07-21 13:16:48 +09:00
ToruNiina	8833292858	doc: rearrange toml::find section in README	2019-07-19 20:42:47 +09:00
ToruNiina	3fe04aff77	doc: fix sample script in README	2019-07-19 20:13:12 +09:00
ToruNiina	138f030b5d	doc: fix sample codes in README	2019-07-18 17:39:24 +09:00