test: add missing include files

test: add test_visit
feat: add multi-argument toml::visit(visitor, ...)
2025-12-16 03:08:52 +08:00 · 2020-02-07 21:00:11 +09:00 · 2020-02-07 15:58:15 +09:00 · 2020-02-07 15:57:34 +09:00 · 2020-02-07 15:57:09 +09:00 · 2020-01-31 22:48:37 +09:00
44 changed files with 1639 additions and 2138 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 -DTOML11_DISALLOW_HETEROGENEOUS_ARRAYS -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 -DTOML11_DISALLOW_HETEROGENEOUS_ARRAYS -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 -DTOML11_DISALLOW_HETEROGENEOUS_ARRAYS -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/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -1,117 +0,0 @@
-name: build
-
-on: [push, pull_request]
-
-jobs:
-  build-linux-gcc:
-    runs-on: Ubuntu-18.04
-    strategy:
-      matrix:
-        # g++-4.8 and 4.9 are tested on Travis.CI.
-        compiler: ['g++-9', 'g++-8', 'g++-7', 'g++-6', 'g++-5']
-        standard: ['11', '14', '17', '20']
-        exclude:
-            - {compiler: 'g++-5', standard: '17'}
-            - {compiler: 'g++-6', standard: '17'}
-            - {compiler: 'g++-5', standard: '20'}
-            - {compiler: 'g++-6', standard: '20'}
-            - {compiler: 'g++-7', standard: '20'}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Install
-        run: |
-            sudo apt-add-repository ppa:mhier/libboost-latest
-            sudo apt-get update
-            sudo apt-get install boost1.70
-            if [[ "${{ matrix.compiler }}" == "g++-6" || "${{ matrix.compiler }}" == "g++-5" ]] ; then
-                sudo apt-add-repository ppa:ubuntu-toolchain-r/test
-                sudo apt-get update
-                sudo apt-get install ${{ matrix.compiler }}
-            fi
-      - name: Configure
-        run: |
-            mkdir build && cd build
-            if [[ "${{ matrix.compiler }}" == "g++-8" && ( "${{ matrix.standard }}" == "17" || "${{ matrix.standard }}" == "20" ) ]] ; then
-                cmake .. -Dtoml11_BUILD_TEST=ON -DCMAKE_CXX_COMPILER=${{ matrix.compiler }} -DCMAKE_CXX_STANDARD=${{ matrix.standard }} -DTOML11_REQUIRE_FILESYSTEM_LIBRARY=ON
-            else
-                cmake .. -Dtoml11_BUILD_TEST=ON -DCMAKE_CXX_COMPILER=${{ matrix.compiler }} -DCMAKE_CXX_STANDARD=${{ matrix.standard }}
-            fi
-      - name: Build
-        run: |
-            cd build && cmake --build .
-      - name: Test
-        run: |
-            cd build && ctest --output-on-failure
-  build-linux-clang:
-    runs-on: Ubuntu-18.04
-    strategy:
-      matrix:
-        compiler: ['10', '9', '8', '7', '6.0', '5.0', '4.0', '3.9']
-        standard: ['11', '14', '17', '20']
-        exclude:
-            - {compiler: '3.9', standard: '17'}
-            - {compiler: '4.0', standard: '17'}
-            - {compiler: '5.0', standard: '17'}
-            - {compiler: '3.9', standard: '20'}
-            - {compiler: '4.0', standard: '20'}
-            - {compiler: '5.0', standard: '20'}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Install
-        run: |
-            sudo apt-add-repository ppa:mhier/libboost-latest
-            sudo apt-get update
-            sudo apt-get install boost1.70
-            if [[ "${{ matrix.compiler }}" != "6" && "${{ matrix.compiler }}" != "8" && "${{ matrix.compiler }}" != "9" ]] ; then
-                sudo apt-add-repository ppa:ubuntu-toolchain-r/test
-                sudo apt-get update
-                sudo apt-get install clang-${{ matrix.compiler }}
-            fi
-      - name: Configure
-        run: |
-            mkdir build && cd build
-            cmake .. -Dtoml11_BUILD_TEST=ON -DCMAKE_CXX_COMPILER=clang++-${{ matrix.compiler }} -DCMAKE_CXX_STANDARD=${{ matrix.standard }}
-      - name: Build
-        run: |
-            cd build && cmake --build .
-      - name: Test
-        run: |
-            cd build && ctest --output-on-failure
-  build-windows-msvc:
-    runs-on: windows-2019
-    strategy:
-      matrix:
-        standard: ['11', '14', '17', '20']
-        config: ['Release', 'Debug']
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - uses: ilammy/msvc-dev-cmd@v1
-      - name: Configure
-        shell: cmd
-        run: |
-            file --mime-encoding tests/test_literals.cpp
-            mkdir build
-            cd build
-            cmake ../ -G "NMake Makefiles" -Dtoml11_BUILD_TEST=ON -DCMAKE_CXX_STANDARD=${{ matrix.standard }} -DBoost_ADDITIONAL_VERSIONS=1.72.0 -DBoost_USE_MULTITHREADED=ON -DBoost_ARCHITECTURE=-x64 -DBoost_NO_BOOST_CMAKE=ON -DBOOST_ROOT=%BOOST_ROOT_1_72_0%
-      - name: Build
-        working-directory: ./build
-        run: |
-            cmake --build . --config "${{ matrix.config }}"
-      - name: Test
-        working-directory: ./build
-        run: |
-            ./tests/test_literals --log_level=all
-            file --mime-encoding tests/toml/tests/example.toml
-            file --mime-encoding tests/toml/tests/fruit.toml
-            file --mime-encoding tests/toml/tests/hard_example.toml
-            file --mime-encoding tests/toml/tests/hard_example_unicode.toml
-            ctest --build-config "${{ matrix.config }}" --output-on-failure
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,30 +2,6 @@ dist: trusty

 matrix:
  include:
-  - os: linux
-    language: cpp
-    compiler: gcc
-    env: COMPILER="g++-4.8" CXX_STANDARD=11
-    addons:
-      apt:
-        sources:
-        - sourceline: 'ppa:ubuntu-toolchain-r/test'
-        - sourceline: 'ppa:mhier/libboost-latest'
-        packages:
-        - g++-4.8
-        - boost1.70
-  - os: linux
-    language: cpp
-    compiler: gcc
-    env: COMPILER="g++-4.9" CXX_STANDARD=11
-    addons:
-      apt:
-        sources:
-        - sourceline: 'ppa:ubuntu-toolchain-r/test'
-        - sourceline: 'ppa:mhier/libboost-latest'
-        packages:
-        - g++-4.9
-        - boost1.70
  - os: linux
    language: cpp
    compiler: gcc
@@ -101,7 +77,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=17 REQUIRE_FILESYSTEM_LIBRARY=ON
+    env: COMPILER="g++-8" CXX_STANDARD=17
    addons:
      apt:
        sources:
@@ -113,7 +89,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=ON REQUIRE_FILESYSTEM_LIBRARY=ON
+    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=ON
    addons:
      apt:
        sources:
@@ -237,7 +213,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=17 REQUIRE_FILESYSTEM_LIBRARY=ON
+    env: COMPILER="clang++-8" CXX_STANDARD=17
    addons:
      apt:
        sources:
@@ -251,7 +227,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=ON REQUIRE_FILESYSTEM_LIBRARY=ON
+    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=ON
    addons:
      apt:
        sources:
@@ -293,6 +269,16 @@ matrix:
  - os: osx
    language: cpp
    compiler: clang
+    env: CXX_STANDARD=11
+    cache:
+      directories:
+        - $HOME/Library/Caches/Homebrew
+    addons:
+      homebrew:
+        update: true
+        packages:
+        - cmake
+        - boost

 script:
 - |
@@ -302,10 +288,6 @@ script:
    tar xf cmake-3.14.5-Linux-x86_64.tar.gz -C cmake --strip-components=1
    export PATH=${TRAVIS_BUILD_DIR}/cmake/bin:${PATH}
  fi
- |
-  if [[ "${CXX_STANDARD}" == "" ]]; then
-      export CXX_STANDARD="11"
-  fi
 - |
  if [[ "${TOML_HEAD}" != "ON" ]]; then
    export TOML_HEAD="OFF"
@@ -321,17 +303,17 @@ script:
    export WITH_UBSAN="OFF"
  fi
 - echo "WITH_UBSAN = ${WITH_UBSAN}"
- echo "REQUIRE_FILESYSTEM_LIBRARY = ${REQUIRE_FILESYSTEM_LIBRARY}"
- |
-  if [[ "${REQUIRE_FILESYSTEM_LIBRARY}" != "ON" ]]; then
-    export REQUIRE_FILESYSTEM_LIBRARY="OFF"
-  fi
- echo "REQUIRE_FILESYSTEM_LIBRARY = ${REQUIRE_FILESYSTEM_LIBRARY}"
 - cmake --version
 - mkdir build
 - cd build
- echo "COMPILER     = ${COMPILER}"
- echo "CXX_STANDARD = ${CXX_STANDARD}"
- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD -DTOML11_REQUIRE_FILESYSTEM_LIBRARY=${REQUIRE_FILESYSTEM_LIBRARY} -Dtoml11_BUILD_TEST=ON -DTOML11_USE_UNRELEASED_TOML_FEATURES=${TOML_HEAD} -Dtoml11_TEST_WITH_ASAN=${WITH_ASAN} -Dtoml11_TEST_WITH_UBSAN=${WITH_UBSAN} ..
+- git clone https://github.com/toml-lang/toml.git
+- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD -DTOML11_USE_UNRELEASED_TOML_FEATURES=${TOML_HEAD} -Dtoml11_TEST_WITH_ASAN=${WITH_ASAN} -Dtoml11_TEST_WITH_UBSAN=${WITH_UBSAN} ..
 - 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
@@ -1,17 +1,26 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 2.8)
 enable_testing()

-project(toml11 VERSION 3.5.0)
+project(toml11)

-option(toml11_BUILD_TEST "Build toml tests" OFF)
+set(toml11_VERSION_MAYOR  3)
+set(toml11_VERSION_MINOR  3)
+set(toml11_VERSION_PATCH  0)
+set(toml11_VERSION
+  "${toml11_VERSION_MAYOR}.${toml11_VERSION_MINOR}.${toml11_VERSION_PATCH}"
+)
+
+option(toml11_BUILD_TEST "Build toml tests" ON)
 option(toml11_TEST_WITH_ASAN  "use LLVM address sanitizer" OFF)
 option(toml11_TEST_WITH_UBSAN "use LLVM undefined behavior sanitizer" OFF)

 include(CheckCXXCompilerFlag)
 if("${CMAKE_VERSION}" VERSION_GREATER 3.1)
-    set(CMAKE_CXX_STANDARD 11 CACHE STRING "The C++ standard whose features are requested to build all targets.")
-    set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "Boolean describing whether the value of CXX_STANDARD is a requirement.")
-    set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Boolean specifying whether compiler specific extensions are requested.")
+    set(CMAKE_CXX_EXTENSIONS OFF)
+    if(NOT DEFINED CMAKE_CXX_STANDARD)
+        set(CMAKE_CXX_STANDARD 11)
+    endif()
+    set(CXX_STANDARD_REQUIRED ON)
 else()
    # Manually check for C++11 compiler flag.
    CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
@@ -37,11 +46,6 @@ else()
    endif()
 endif()

-if(MSVC)
-    add_definitions("/Zc:__cplusplus") # define __cplusplus value correctly
-    add_definitions("/utf-8")          # enable to use u8"" literal
-endif()
-
 # Set some common directories
 include(GNUInstallDirs)
 set(toml11_install_cmake_dir         ${CMAKE_INSTALL_LIBDIR}/cmake/toml11)
--- a/README.md
+++ b/README.md
@@ -1,7 +1,6 @@
 toml11
 ======

-[![Build Status on GitHub Actions](https://github.com/ToruNiina/toml11/workflows/build/badge.svg)](https://github.com/ToruNiina/toml11/actions)
 [![Build Status on TravisCI](https://travis-ci.org/ToruNiina/toml11.svg?branch=master)](https://travis-ci.org/ToruNiina/toml11)
 [![Build status on Appveyor](https://ci.appveyor.com/api/projects/status/m2n08a926asvg5mg/branch/master?svg=true)](https://ci.appveyor.com/project/ToruNiina/toml11/branch/master)
 [![Build status on CircleCI](https://circleci.com/gh/ToruNiina/toml11/tree/master.svg?style=svg)](https://circleci.com/gh/ToruNiina/toml11/tree/master)
@@ -9,16 +8,16 @@ toml11
 [![License](https://img.shields.io/github/license/ToruNiina/toml11.svg?style=flat)](LICENSE)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1209136.svg)](https://doi.org/10.5281/zenodo.1209136)

-toml11 is a C++11 (or later) header-only toml parser/encoder depending only on C++ standard library.
+toml11 is a C++11 header-only toml parser/encoder depending only on C++ standard library.

- It is compatible to the latest version of [TOML v1.0.0-rc.2](https://toml.io/en/v1.0.0-rc.2).
- It is one of the most TOML standard compliant libraries, tested with [the language agnostic test suite for TOML parsers by BurntSushi](https://github.com/BurntSushi/toml-test).
- It shows highly informative error messages. You can see the error messages about invalid files at [CircleCI](https://circleci.com/gh/ToruNiina/toml11).
- It has configurable container. You can use any random-access containers and key-value maps as backend containers.
- It optionally preserves comments without any overhead.
- It has configurable serializer that supports comments, inline tables, literal strings and multiline strings.
- It supports user-defined type conversion from/into toml values.
- It correctly handles UTF-8 sequences, with or without BOM, both on posix and Windows.
+compatible to the latest version of
+[TOML v0.5.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.5.0.md)
+after version 2.0.0.
+
+It passes [the language agnostic test suite for TOML parsers by BurntSushi](https://github.com/BurntSushi/toml-test).
+Not only the test suite itself, a TOML reader/encoder also runs on [CircleCI](https://circleci.com/gh/ToruNiina/toml11).
+You can see the error messages about invalid files and serialization results of valid files at
+[CircleCI](https://circleci.com/gh/ToruNiina/toml11).

 ## Example

@@ -28,25 +27,15 @@ toml11 is a C++11 (or later) header-only toml parser/encoder depending only on C

 int main()
 {
-    auto data = toml::parse("example.toml");
+    const auto data = toml::parse("example.toml");

-    // find a value with the specified type from a table
+    // title = "an example toml file"
    std::string title = toml::find<std::string>(data, "title");
+    std::cout << "the title is " << title << std::endl;

-    // convert the whole array into any container automatically
-    std::vector<int> nums = toml::find<std::vector<int>>(data, "nums");
-
-    // access with STL-like manner
-    if(not data.at("a").contains("b"))
-    {
-        data["a"]["b"] = "c";
-    }
-
-    // pass a fallback
-    std::string name = toml::find_or<std::string>(data, "name", "not found");
-
-    // width-dependent formatting
-    std::cout << std::setw(80) << data << std::endl;
+    // nums = [1, 2, 3, 4, 5]
+    std::vector<int> nums  = toml::find<std::vector<int>>(data, "nums");
+    std::cout << "the length of `nums` is" << nums.size() << std::endl;

    return 0;
 }
@@ -95,7 +84,7 @@ int main()
 Just include the file after adding it to the include path.

 ```cpp
-#include <toml.hpp> // that's all! now you can use it.
+#include <toml11/toml.hpp> // that's all! now you can use it.
 #include <iostream>

 int main()
@@ -110,8 +99,6 @@ int main()
 The convenient way is to add this repository as a git-submodule or to install
 it in your system by CMake.

-Note for MSVC: We recommend to set `/Zc:__cplusplus` to detect C++ version correctly.
-
 ## Decoding a toml file

 To parse a toml file, the only thing you have to do is
@@ -122,9 +109,6 @@ const std::string fname("sample.toml");
 const toml::value data = toml::parse(fname);
 ```

-As required by the TOML specification, the top-level value is always a table.
-You can find a value inside it, cast it into a table explicitly, and insert it as a value into other `toml::value`.
-
 If it encounters an error while opening a file, it will throw `std::runtime_error`.

 You can also pass a `std::istream` to the  `toml::parse` function.
@@ -182,7 +166,7 @@ what(): [error] bad time: should be HH:MM:SS.subsec
 --> ./datetime-malformed-no-secs.toml
 1 | no-secs = 1987-07-05T17:45Z
   |                     ^------- HH:MM:SS.subsec
-   |
+   | 
 Hint: pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999
 Hint: fail: 1979-05-27T7:32:00, 1979-05-27 17:32
 ```
@@ -272,11 +256,11 @@ shape = "round"
 ``` cpp
 const auto  data  = toml::parse("fruit.toml");
 const auto& fruit = toml::find(data, "fruit");
-const auto  name  = toml::find<std::string>(fruit, "name");
+const auto  name  = toml::find<std::string>(fruit, "apple");

 const auto& physical = toml::find(fruit, "physical");
-const auto  color    = toml::find<std::string>(physical, "color");
-const auto  shape    = toml::find<std::string>(physical, "shape");
+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
@@ -468,24 +452,6 @@ if(answer.is_integer() && answer.as_integer(std::nothrow) == 42)

 If `std::nothrow` is passed, the functions are marked as noexcept.

-By casting a `toml::value` into an array or a table, you can iterate over the
-elements.
-
-```cpp
-const auto data = toml::parse("example.toml");
-std::cout << "keys in the top-level table are the following: \n";
-for(const auto& [k, v] : data.as_table())
-{
-    std::cout << k << '\n';
-}
-
-const auto& fruits = toml::find(data, "fruits");
-for(const auto& v : fruits.as_array())
-{
-    std::cout << toml::find<std::string>(v, "name") << '\n';
-}
-```
-
 The full list of the functions is below.

 ```cpp
@@ -1447,7 +1413,7 @@ const toml::source_location loc = v.location();

 ## Exceptions

-The following `exception` classes inherits `toml::exception` that inherits
+All the exceptions thrown by toml11 inherits `toml::exception` that inherits
 `std::exception`.

 ```cpp
@@ -1474,16 +1440,6 @@ struct exception : public std::exception

 It represents where the error occurs.

-`syntax_error` will be thrown from `toml::parse` and `_toml` literal.
-`type_error` will be thrown from `toml::get/find`, `toml::value::as_xxx()`, and
-other functions that takes a content inside of `toml::value`.
-
-Note that, currently, from `toml::value::at()` and `toml::find(value, key)`
-may throw an `std::out_of_range` that does not inherits `toml::exception`.
-
-Also, in some cases, most likely in the file open error, it will throw an
-`std::runtime_error`.
-
 ## Colorize Error Messages

 By defining `TOML11_COLORIZE_ERROR_MESSAGE`, the error messages from
@@ -1675,8 +1631,13 @@ not capable of representing a Local Time independent from a specific day.

 ## Unreleased TOML features

-Since TOML v1.0.0-rc.1 has been released, those features are now activated by
-default. We no longer need to define `TOML11_USE_UNRELEASED_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`
@@ -1686,10 +1647,10 @@ default. We no longer need to define `TOML11_USE_UNRELEASED_FEATURES`.
 - Allow heterogeneous arrays
  - [toml-lang/toml/PR/676](https://github.com/toml-lang/toml/pull/676)

-## Note about heterogeneous arrays
+### Note about heterogeneous arrays

 Although `toml::parse` allows heterogeneous arrays, constructor of `toml::value`
-does not. Here the reason is explained.
+does not.

 ```cpp
 // this won't be compiled
@@ -1698,10 +1659,8 @@ toml::value v{
 }
 ```

-There is a workaround for this. By explicitly converting values into
+There is a workaround for this issue. By explicitly converting values into
 `toml::value`, you can initialize `toml::value` with a heterogeneous array.
-Also, you can first initialize a `toml::value` with an array and then
-`push_back` into it.

 ```cpp
 // OK!
@@ -1709,17 +1668,6 @@ toml::value v{
    toml::value("foo"), toml::value(3.14), toml::value(42),
    toml::value{1,2,3,4,5}, toml::value{{"key", "value"}}
 }
-
-// OK!
-toml::value v(toml::array{});
-v.push_back("foo");
-v.push_back(3.14);
-
-// OK!
-toml::array a;
-a.push_back("foo");
-a.push_back(3.14);
-toml::value v(std::move(a));
 ```

 The reason why the first example is not allowed is the following.
@@ -1748,14 +1696,15 @@ 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, we need to explicitly cast values into
-`toml::value` when you initialize heterogeneous array in a C++ code.
+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
@@ -1794,13 +1743,14 @@ Such a big change will not happen in the coming years.

 ## Running Tests

-After cloning this repository, run the following command (thank you @jwillikers
-for automating test set fetching!).
+To run test codes, you need to clone toml-lang/toml repository under `build/` directory
+because some of the test codes read a file in the repository.

 ```sh
 $ mkdir build
 $ cd build
-$ cmake .. -Dtoml11_BUILD_TEST=ON
+$ git clone https://github.com/toml-lang/toml.git
+$ cmake ..
 $ make
 $ make test
 ```
@@ -1833,22 +1783,6 @@ I appreciate the help of the contributors who introduced the great feature to th
  - Suppress warnings in Debug mode
 - OGAWA Kenichi (@kenichiice)
  - Suppress warnings on intel compiler
- Jordan Williams (@jwillikers)
-  - Fixed clang range-loop-analysis warnings
-  - Fixed feature test macro to suppress -Wundef
-  - Use cache variables in CMakeLists.txt
-  - Automate test set fetching, update and refactor CMakeLists.txt
- Scott McCaskill
-  - Parse 9 digits (nanoseconds) of fractional seconds in a `local_time`
- Shu Wang (@halfelf)
-  - fix "Finding a value in an array" example in README
- @maass-tv and @SeverinLeonhardt
-  - Fix MSVC warning C4866
- OGAWA KenIchi (@kenichiice)
-  - Fix include path in README
- Mohammed Alyousef (@MoAlyousef)
-  - Made testing optional in CMake
-

 ## Licensing terms

--- a/appveyor.yml
+++ b/appveyor.yml
@@ -17,9 +17,10 @@ build_script:
  - cd C:\toml11
  - mkdir build
  - cd build
-  - cmake -G"%generator%" -DBOOST_ROOT=C:/Libraries/boost_1_69_0 -Dtoml11_BUILD_TEST=ON ..
+  - git clone https://github.com/toml-lang/toml.git
+  - file --mime-encoding toml/tests/hard_example_unicode.toml
+  - cmake -G"%generator%" -DBOOST_ROOT=C:/Libraries/boost_1_69_0 ..
  - cmake --build . --config "%configuration%"
-  - file --mime-encoding tests/toml/tests/hard_example_unicode.toml

 test_script:
  - ctest --build-config "%configuration%" --timeout 300 --output-on-failure
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,12 +1,3 @@
-include(ExternalProject)
-ExternalProject_Add(toml
-        SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/toml
-        GIT_REPOSITORY https://github.com/toml-lang/toml
-        GIT_TAG v0.5.0
-        CONFIGURE_COMMAND ""
-        BUILD_COMMAND ""
-        INSTALL_COMMAND "")
-
 set(TEST_NAMES
    test_datetime
    test_string
@@ -43,6 +34,7 @@ set(TEST_NAMES
    test_error_detection
    test_format_error
    test_extended_conversions
+    test_visit
 )

 CHECK_CXX_COMPILER_FLAG("-Wall"      COMPILER_SUPPORTS_WALL)
@@ -57,8 +49,6 @@ CHECK_CXX_COMPILER_FLAG("-Wduplicated-branches" COMPILER_SUPPORTS_WDUPLICATED_BR
 CHECK_CXX_COMPILER_FLAG("-Wlogical-op"          COMPILER_SUPPORTS_WLOGICAL_OP)
 CHECK_CXX_COMPILER_FLAG("-Wuseless-cast"        COMPILER_SUPPORTS_WUSELESS_CAST)
 CHECK_CXX_COMPILER_FLAG("-Wdouble-promotion"    COMPILER_SUPPORTS_WDOUBLE_PROMOTION)
-CHECK_CXX_COMPILER_FLAG("-Wrange-loop-analysis" COMPILER_SUPPORTS_WRANGE_LOOP_ANALYSIS)
-CHECK_CXX_COMPILER_FLAG("-Wundef"               COMPILER_SUPPORTS_WUNDEF)

 if(COMPILER_SUPPORTS_WALL)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
@@ -93,12 +83,6 @@ endif()
 if(COMPILER_SUPPORTS_WDOUBLE_PROMOTION)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdouble-promotion")
 endif()
-if(COMPILER_SUPPORTS_WRANGE_LOOP_ANALYSIS)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wrange-loop-analysis")
-endif()
-if(COMPILER_SUPPORTS_WUNDEF)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wundef")
-endif()

 option(TOML11_USE_UNRELEASED_TOML_FEATURES
    "use features in toml-lang/toml master while testing" OFF)
@@ -150,46 +134,9 @@ find_package(Boost COMPONENTS unit_test_framework REQUIRED)
 add_definitions(-DBOOST_TEST_DYN_LINK)
 add_definitions(-DUNITTEST_FRAMEWORK_LIBRARY_EXIST)

-# check which standard library implementation is used. If libstdc++ is used,
-# it will fail to compile. It compiles if libc++ is used.
-include(CheckCXXSourceCompiles)
-check_cxx_source_compiles("
-#include <cstddef>
-#ifdef __GLIBCXX__
-    static_assert(false);
-#endif
-int main() {
-    return 0;
-}" TOML11_WITH_LIBCXX_LIBRARY)
-
-# LLVM 8 requires -lc++fs if compiled with libc++ to use <filesystem>.
-# LLVM 9+ does not require any special library.
-# GCC 8 requires -lstdc++fs. GCC 9+ does not require it.
-#
-# Yes, we can check the version of the compiler used in the current build
-# directly in CMake. But, in most cases, clang build uses libstdc++ as the
-# standard library implementation and it makes the condition complicated.
-# In many environment, the default installed C++ compiler is GCC and libstdc++
-# is installed along with it. In most build on such an environment, even if we
-# chose clang as the C++ compiler, still libstdc++ is used. Checking default
-# gcc version makes the condition complicated.
-# The purpose of this file is to compile tests. We know the environment on which
-# the tests run. We can set this option and, I think, it is easier and better.
-option(TOML11_REQUIRE_FILESYSTEM_LIBRARY "need to link -lstdc++fs or -lc++fs" OFF)
-
 foreach(TEST_NAME ${TEST_NAMES})
    add_executable(${TEST_NAME} ${TEST_NAME}.cpp)
    target_link_libraries(${TEST_NAME} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} toml11::toml11)
-
-    # to compile tests with <filesystem>...
-    if(TOML11_REQUIRE_FILESYSTEM_LIBRARY)
-        if(TOML11_WITH_LIBCXX_LIBRARY)
-            target_link_libraries(${TEST_NAME} "c++fs")
-        else()
-            target_link_libraries(${TEST_NAME} "stdc++fs")
-        endif()
-    endif()
-
    target_include_directories(${TEST_NAME} PRIVATE ${Boost_INCLUDE_DIRS})

    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
@@ -204,7 +151,7 @@ foreach(TEST_NAME ${TEST_NAMES})
        endif()
    endif()

-    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME} WORKING_DIRECTORY ${PROJECT_BINARY_DIR})

    # Set the PATH to be able to find Boost DLL
    if(WIN32)
@@ -215,15 +162,8 @@ foreach(TEST_NAME ${TEST_NAMES})
    endif()
 endforeach(TEST_NAME)

-
 # this test is to check it compiles. it will not run
 add_executable(test_multiple_translation_unit
               test_multiple_translation_unit_1.cpp
               test_multiple_translation_unit_2.cpp)
 target_link_libraries(test_multiple_translation_unit toml11::toml11)
-
-if(WIN32)
-    add_executable(test_windows test_windows.cpp)
-    target_link_libraries(test_windows toml11::toml11)
-endif()
-
--- a/tests/check_toml_test.cpp
+++ b/tests/check_toml_test.cpp
@@ -84,7 +84,9 @@ struct json_serializer
        {
            if(!is_first) {std::cout << ", ";}
            is_first = false;
-            std::cout << this->format_key(elem.first) << ':';
+            std::cout << toml::format(toml::value(elem.first),
+                    std::numeric_limits<std::size_t>::max());
+            std::cout << ':';
            toml::visit(*this, elem.second);
        }
        std::cout << '}';
@@ -110,12 +112,6 @@ struct json_serializer
        }
        return retval;
    }
-
-    std::string format_key(const std::string& s) const
-    {
-        const auto quote("\"");
-        return quote + escape_string(s) + quote;
-    }
 };

 int main()
--- a/tests/test_comments.cpp
+++ b/tests/test_comments.cpp
@@ -11,7 +11,7 @@
 BOOST_AUTO_TEST_CASE(test_comment_before)
 {
    {
-        const std::string file = R"(
+        const std::string file = u8R"(
            # comment for a.
            a = 42
            # comment for b.
@@ -24,12 +24,12 @@ BOOST_AUTO_TEST_CASE(test_comment_before)
        const auto& b = toml::find(v, "b");

        BOOST_TEST(a.comments().size()  == 1u);
-        BOOST_TEST(a.comments().front() == " comment for a.");
+        BOOST_TEST(a.comments().front() == u8" comment for a.");
        BOOST_TEST(b.comments().size()  == 1u);
-        BOOST_TEST(b.comments().front() == " comment for b.");
+        BOOST_TEST(b.comments().front() == u8" comment for b.");
    }
    {
-        const std::string file = R"(
+        const std::string file = u8R"(
            # comment for a.
            # another comment for a.
            a = 42
@@ -45,18 +45,18 @@ BOOST_AUTO_TEST_CASE(test_comment_before)
        const auto& b = toml::find(v, "b");

        BOOST_TEST(a.comments().size()  == 2u);
-        BOOST_TEST(a.comments().front() == " comment for a.");
-        BOOST_TEST(a.comments().back()  == " another comment for a.");
+        BOOST_TEST(a.comments().front() == u8" comment for a.");
+        BOOST_TEST(a.comments().back()  == u8" another comment for a.");
        BOOST_TEST(b.comments().size()  == 2u);
-        BOOST_TEST(b.comments().front() == " comment for b.");
-        BOOST_TEST(b.comments().back()  == " also comment for b.");
+        BOOST_TEST(b.comments().front() == u8" comment for b.");
+        BOOST_TEST(b.comments().back()  == u8" also comment for b.");
    }
 }

 BOOST_AUTO_TEST_CASE(test_comment_inline)
 {
    {
-        const std::string file = R"(
+        const std::string file = u8R"(
            a = 42    # comment for a.
            b = "baz" # comment for b.
        )";
@@ -68,12 +68,12 @@ BOOST_AUTO_TEST_CASE(test_comment_inline)
        const auto& b = toml::find(v, "b");

        BOOST_TEST(a.comments().size()  == 1u);
-        BOOST_TEST(a.comments().front() == " comment for a.");
+        BOOST_TEST(a.comments().front() == u8" comment for a.");
        BOOST_TEST(b.comments().size()  == 1u);
-        BOOST_TEST(b.comments().front() == " comment for b.");
+        BOOST_TEST(b.comments().front() == u8" comment for b.");
    }
    {
-        const std::string file = R"(
+        const std::string file = u8R"(
            a = [
                42,
            ] # comment for a.
@@ -90,18 +90,18 @@ BOOST_AUTO_TEST_CASE(test_comment_inline)
        const auto& b0 = b.as_array().at(0);

        BOOST_TEST(a.comments().size()   == 1u);
-        BOOST_TEST(a.comments().front()  == " comment for a.");
+        BOOST_TEST(a.comments().front()  == u8" comment for a.");
        BOOST_TEST(b.comments().size()   == 1u);
-        BOOST_TEST(b.comments().front()  == " this is a comment for b.");
+        BOOST_TEST(b.comments().front()  == u8" this is a comment for b.");
        BOOST_TEST(b0.comments().size()  == 1u);
-        BOOST_TEST(b0.comments().front() == " this is not a comment for b, but \"bar\"");
+        BOOST_TEST(b0.comments().front() == u8" this is not a comment for b, but \"bar\"");
    }
 }

 BOOST_AUTO_TEST_CASE(test_comment_both)
 {
    {
-        const std::string file = R"(
+        const std::string file = u8R"(
            # comment for a.
            a = 42 # inline comment for a.
            # comment for b.
@@ -122,25 +122,25 @@ BOOST_AUTO_TEST_CASE(test_comment_both)
        const auto& c0 = c.as_array().at(0);

        BOOST_TEST(a.comments().size()  == 2u);
-        BOOST_TEST(a.comments().front() == " comment for a.");
-        BOOST_TEST(a.comments().back()  == " inline comment for a.");
+        BOOST_TEST(a.comments().front() == u8" comment for a.");
+        BOOST_TEST(a.comments().back()  == u8" inline comment for a.");
        BOOST_TEST(b.comments().size()  == 2u);
-        BOOST_TEST(b.comments().front() == " comment for b.");
-        BOOST_TEST(b.comments().back()  == " inline comment for b.");
+        BOOST_TEST(b.comments().front() == u8" comment for b.");
+        BOOST_TEST(b.comments().back()  == u8" inline comment for b.");

        BOOST_TEST(c.comments().size()  == 2u);
-        BOOST_TEST(c.comments().front() == " comment for c.");
-        BOOST_TEST(c.comments().back()  == " another comment for c.");
+        BOOST_TEST(c.comments().front() == u8" comment for c.");
+        BOOST_TEST(c.comments().back()  == u8" another comment for c.");

        BOOST_TEST(c0.comments().size()  == 2u);
-        BOOST_TEST(c0.comments().front() == " comment for the first element.");
-        BOOST_TEST(c0.comments().back()  == " this also.");
+        BOOST_TEST(c0.comments().front() == u8" comment for the first element.");
+        BOOST_TEST(c0.comments().back()  == u8" this also.");
    }
 }

 BOOST_AUTO_TEST_CASE(test_discard_comment)
 {
-    const std::string file = R"(
+    const std::string file = u8R"(
        # comment for a.
        a = 42 # inline comment for a.
        # comment for b.
--- a/tests/test_error_detection.cpp
+++ b/tests/test_error_detection.cpp
@@ -80,13 +80,13 @@ BOOST_AUTO_TEST_CASE(test_detect_conflicting_value)

 BOOST_AUTO_TEST_CASE(test_detect_inhomogeneous_array)
 {
-#ifdef TOML11_DISALLOW_HETEROGENEOUS_ARRAYS
+#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);
-#else
-    BOOST_TEST_MESSAGE("After v1.0.0-rc.1, heterogeneous arrays are allowed");
 #endif
 }

--- a/tests/test_extended_conversions.cpp
+++ b/tests/test_extended_conversions.cpp
@@ -47,6 +47,8 @@ struct qux

 struct foobar
 {
+    foobar() = default; // later we use std::vector<foobar>, default ctor is required.
+
    // via constructor
    explicit foobar(const toml::value& v)
        : a(toml::find<int>(v, "a")), b(toml::find<std::string>(v, "b"))
@@ -135,6 +137,8 @@ struct qux

 struct foobar
 {
+    foobar() = default; // later we use std::vector<foobar>, default ctor is required.
+
    template<typename C, template<typename ...> class M, template<typename ...> class A>
    explicit foobar(const toml::basic_value<C, M, A>& v)
        : a(toml::find<int>(v, "a")), b(toml::find<std::string>(v, "b"))
@@ -484,64 +488,5 @@ BOOST_AUTO_TEST_CASE(test_recursive_conversion)
        BOOST_TEST(foobars.at(2).b == "quux");
        BOOST_TEST(foobars.at(3).b == "foobar");
    }
-
-    // via constructor
-    {
-        const toml::value v{
-                {"0", toml::table{{"a", 42}, {"b", "baz"}}},
-                {"1", toml::table{{"a", 43}, {"b", "qux"}}},
-                {"2", toml::table{{"a", 44}, {"b", "quux"}}},
-                {"3", toml::table{{"a", 45}, {"b", "foobar"}}}
-            };
-
-        {
-            const auto foobars = toml::get<std::map<std::string, extlib::foobar>>(v);
-            BOOST_TEST(foobars.size()  == 4ul);
-            BOOST_TEST(foobars.at("0").a == 42);
-            BOOST_TEST(foobars.at("1").a == 43);
-            BOOST_TEST(foobars.at("2").a == 44);
-            BOOST_TEST(foobars.at("3").a == 45);
-
-            BOOST_TEST(foobars.at("0").b == "baz");
-            BOOST_TEST(foobars.at("1").b == "qux");
-            BOOST_TEST(foobars.at("2").b == "quux");
-            BOOST_TEST(foobars.at("3").b == "foobar");
-        }
-        {
-            const auto foobars = toml::get<std::map<std::string, extlib2::foobar>>(v);
-            BOOST_TEST(foobars.size()  == 4ul);
-            BOOST_TEST(foobars.at("0").a == 42);
-            BOOST_TEST(foobars.at("1").a == 43);
-            BOOST_TEST(foobars.at("2").a == 44);
-            BOOST_TEST(foobars.at("3").a == 45);
-
-            BOOST_TEST(foobars.at("0").b == "baz");
-            BOOST_TEST(foobars.at("1").b == "qux");
-            BOOST_TEST(foobars.at("2").b == "quux");
-            BOOST_TEST(foobars.at("3").b == "foobar");
-        }
-    }
-    {
-        const toml::basic_value<toml::discard_comments, std::map, std::deque>
-            v{
-                {"0", toml::table{{"a", 42}, {"b", "baz"}}},
-                {"1", toml::table{{"a", 43}, {"b", "qux"}}},
-                {"2", toml::table{{"a", 44}, {"b", "quux"}}},
-                {"3", toml::table{{"a", 45}, {"b", "foobar"}}}
-            };
-
-        const auto foobars = toml::get<std::map<std::string, extlib::foobar>>(v);
-        BOOST_TEST(foobars.size()  == 4ul);
-        BOOST_TEST(foobars.at("0").a == 42);
-        BOOST_TEST(foobars.at("1").a == 43);
-        BOOST_TEST(foobars.at("2").a == 44);
-        BOOST_TEST(foobars.at("3").a == 45);
-
-        BOOST_TEST(foobars.at("0").b == "baz");
-        BOOST_TEST(foobars.at("1").b == "qux");
-        BOOST_TEST(foobars.at("2").b == "quux");
-        BOOST_TEST(foobars.at("3").b == "foobar");
-    }
-
 }

--- a/tests/test_lex_aux.hpp
+++ b/tests/test_lex_aux.hpp
@@ -8,7 +8,7 @@
 do {                                                                           \
    const std::string token   (tkn);                                           \
    const std::string expected(expct);                                         \
-    toml::detail::location loc("test", token);                                 \
+    toml::detail::location<std::string> loc("test", token);                    \
    const auto result = lxr::invoke(loc);                                      \
    BOOST_TEST(result.is_ok());                                                \
    if(result.is_ok()){                                                        \
@@ -28,7 +28,7 @@ do {                                                                           \
 #define TOML11_TEST_LEX_REJECT(lxr, tkn)                                       \
 do {                                                                           \
    const std::string token   (tkn);                                           \
-    toml::detail::location loc("test", token);                                 \
+    toml::detail::location<std::string> loc("test", token);                    \
    const auto result = lxr::invoke(loc);                                      \
    BOOST_TEST(result.is_err());                                               \
    const bool loc_same = (loc.begin() == loc.iter());                         \
--- a/tests/test_lex_key_comment.cpp
+++ b/tests/test_lex_key_comment.cpp
@@ -18,11 +18,12 @@ BOOST_AUTO_TEST_CASE(test_quoted_key)
 {
    TOML11_TEST_LEX_ACCEPT(lex_key, "\"127.0.0.1\"", "\"127.0.0.1\"");
    TOML11_TEST_LEX_ACCEPT(lex_key, "\"character encoding\"", "\"character encoding\"");
-
-    // UTF-8 codepoint of characters that looks like "key" written upside down
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
    TOML11_TEST_LEX_ACCEPT(lex_key, "\"\xCA\x8E\xC7\x9D\xCA\x9E\"",
                                    "\"\xCA\x8E\xC7\x9D\xCA\x9E\"");
-
+#else
+    TOML11_TEST_LEX_ACCEPT(lex_key, u8"\"ʎǝʞ\"", u8"\"ʎǝʞ\"");
+#endif
    TOML11_TEST_LEX_ACCEPT(lex_key, "'key2'", "'key2'");
    TOML11_TEST_LEX_ACCEPT(lex_key, "'quoted \"value\"'", "'quoted \"value\"'");
 }
--- a/tests/test_lex_string.cpp
+++ b/tests/test_lex_string.cpp
@@ -31,9 +31,15 @@ BOOST_AUTO_TEST_CASE(test_basic_string)
            "\"192.168.1.1\"",
            "\"192.168.1.1\"");

+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
    TOML11_TEST_LEX_ACCEPT(lex_string,
-            "\"\xE4\xB8\xAD\xE5\x9B\xBD\"",  // UTF-8 string (means "China" in
-            "\"\xE4\xB8\xAD\xE5\x9B\xBD\""); // Chinese characters)
+            "\"\xE4\xB8\xAD\xE5\x9B\xBD\"",
+            "\"\xE4\xB8\xAD\xE5\x9B\xBD\"");
+#else
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+            u8"\"中国\"",
+            u8"\"中国\"");
+#endif

    TOML11_TEST_LEX_ACCEPT(lex_string,
            "\"You'll hate me after this - #\"",
@@ -51,22 +57,6 @@ BOOST_AUTO_TEST_CASE(test_ml_basic_string)
    TOML11_TEST_LEX_ACCEPT(lex_string,
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"",
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"");
-
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"",
-        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"");
-
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"",
-        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"");
-
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"",
-        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"");
-
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"",
-        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"");
 }

 BOOST_AUTO_TEST_CASE(test_literal_string)
@@ -93,16 +83,4 @@ BOOST_AUTO_TEST_CASE(test_ml_literal_string)
    TOML11_TEST_LEX_ACCEPT(lex_string,
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''",
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''");
-
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-        "''''That's still pointless', she said.'''",
-        "''''That's still pointless', she said.'''");
-
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''",
-        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''");
-
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-        "''''This,' she said, 'is just a pointless statement.''''",
-        "''''This,' she said, 'is just a pointless statement.''''");
 }
--- a/tests/test_literals.cpp
+++ b/tests/test_literals.cpp
@@ -14,7 +14,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)

    {
        const toml::value r{{"a", 42}, {"b", "baz"}};
-        const toml::value v = R"(
+        const toml::value v = u8R"(
            a = 42
            b = "baz"
        )"_toml;
@@ -26,7 +26,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
            {"c", 3.14},
            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
        };
-        const toml::value v = R"(
+        const toml::value v = u8R"(
            c = 3.14
            [table]
            a = 42
@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
        const toml::value r{
            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
        };
-        const toml::value v = R"(
+        const toml::value v = u8R"(
            [table]
            a = 42
            b = "baz"
@@ -51,7 +51,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
        const toml::value r{
            {"array_of_tables", toml::array{toml::table{}}}
        };
-        const toml::value v = R"(
+        const toml::value v = u8R"(
            [[array_of_tables]]
        )"_toml;

@@ -63,170 +63,6 @@ BOOST_AUTO_TEST_CASE(test_value_as_literal)
 {
    using namespace toml::literals::toml_literals;

-    {
-        const toml::value v1 = "true"_toml;
-        const toml::value v2 = "false"_toml;
-
-        BOOST_TEST(v1.is_boolean());
-        BOOST_TEST(v2.is_boolean());
-        BOOST_TEST(toml::get<bool>(v1));
-        BOOST_TEST(!toml::get<bool>(v2));
-    }
-    {
-        const toml::value v1 = "123_456"_toml;
-        const toml::value v2 = "0b0010"_toml;
-        const toml::value v3 = "0xDEADBEEF"_toml;
-
-        BOOST_TEST(v1.is_integer());
-        BOOST_TEST(v2.is_integer());
-        BOOST_TEST(v3.is_integer());
-        BOOST_TEST(toml::get<toml::integer>(v1) == 123456);
-        BOOST_TEST(toml::get<toml::integer>(v2) == 2);
-        BOOST_TEST(toml::get<toml::integer>(v3) == 0xDEADBEEF);
-    }
-    {
-        const toml::value v1 = "3.1415"_toml;
-        const toml::value v2 = "6.02e+23"_toml;
-
-        BOOST_TEST(v1.is_floating());
-        BOOST_TEST(v2.is_floating());
-        BOOST_TEST(toml::get<double>(v1) == 3.1415,  boost::test_tools::tolerance(0.00001));
-        BOOST_TEST(toml::get<double>(v2) == 6.02e23, boost::test_tools::tolerance(0.0001));
-    }
-    {
-        const toml::value v1 = R"("foo")"_toml;
-        const toml::value v2 = R"('foo')"_toml;
-        const toml::value v3 = R"("""foo""")"_toml;
-        const toml::value v4 = R"('''foo''')"_toml;
-
-        BOOST_TEST(v1.is_string());
-        BOOST_TEST(v2.is_string());
-        BOOST_TEST(v3.is_string());
-        BOOST_TEST(v4.is_string());
-        BOOST_TEST(toml::get<std::string>(v1) == "foo");
-        BOOST_TEST(toml::get<std::string>(v2) == "foo");
-        BOOST_TEST(toml::get<std::string>(v3) == "foo");
-        BOOST_TEST(toml::get<std::string>(v4) == "foo");
-    }
-    {
-        {
-            const toml::value v1 = R"([1,2,3])"_toml;
-            BOOST_TEST(v1.is_array());
-            const bool result = (toml::get<std::vector<int>>(v1) == std::vector<int>{1,2,3});
-            BOOST_TEST(result);
-        }
-        {
-            const toml::value v2 = R"([1,])"_toml;
-            BOOST_TEST(v2.is_array());
-            const bool result = (toml::get<std::vector<int>>(v2) == std::vector<int>{1});
-            BOOST_TEST(result);
-        }
-        {
-            const toml::value v3 = R"([[1,]])"_toml;
-            BOOST_TEST(v3.is_array());
-            const bool result = (toml::get<std::vector<int>>(toml::get<toml::array>(v3).front()) == std::vector<int>{1});
-            BOOST_TEST(result);
-        }
-        {
-            const toml::value v4 = R"([[1],])"_toml;
-            BOOST_TEST(v4.is_array());
-            const bool result = (toml::get<std::vector<int>>(toml::get<toml::array>(v4).front()) == std::vector<int>{1});
-            BOOST_TEST(result);
-        }
-    }
-    {
-        const toml::value v1 = R"({a = 42})"_toml;
-
-        BOOST_TEST(v1.is_table());
-        const bool result = toml::get<std::map<std::string,int>>(v1) ==
-                               std::map<std::string,int>{{"a", 42}};
-        BOOST_TEST(result);
-    }
-    {
-        const toml::value v1 = "1979-05-27"_toml;
-
-        BOOST_TEST(v1.is_local_date());
-        BOOST_TEST(toml::get<toml::local_date>(v1) ==
-                   toml::local_date(1979, toml::month_t::May, 27));
-    }
-    {
-        const toml::value v1 = "12:00:00"_toml;
-
-        BOOST_TEST(v1.is_local_time());
-        const bool result = toml::get<std::chrono::hours>(v1) == std::chrono::hours(12);
-        BOOST_TEST(result);
-    }
-    {
-        const toml::value v1 = "1979-05-27T07:32:00"_toml;
-        BOOST_TEST(v1.is_local_datetime());
-        BOOST_TEST(toml::get<toml::local_datetime>(v1) ==
-            toml::local_datetime(toml::local_date(1979, toml::month_t::May, 27),
-                                 toml::local_time(7, 32, 0)));
-    }
-    {
-        const toml::value v1 = "1979-05-27T07:32:00Z"_toml;
-        BOOST_TEST(v1.is_offset_datetime());
-        BOOST_TEST(toml::get<toml::offset_datetime>(v1) ==
-            toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
-                                  toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
-    }
-}
-
-BOOST_AUTO_TEST_CASE(test_file_as_u8_literal)
-{
-    using namespace toml::literals::toml_literals;
-
-    {
-        const toml::value r{{"a", 42}, {"b", "baz"}};
-        const toml::value v = u8R"(
-            a = 42
-            b = "baz"
-        )"_toml;
-
-        BOOST_TEST(r == v);
-    }
-    {
-        const toml::value r{
-            {"c", 3.14},
-            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
-        };
-        const toml::value v = u8R"(
-            c = 3.14
-            [table]
-            a = 42
-            b = "baz"
-        )"_toml;
-
-        BOOST_TEST(r == v);
-    }
-    {
-        const toml::value r{
-            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
-        };
-        const toml::value v = u8R"(
-            [table]
-            a = 42
-            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);
-    }
-}
-
-BOOST_AUTO_TEST_CASE(test_value_as_u8_literal)
-{
-    using namespace toml::literals::toml_literals;
-
    {
        const toml::value v1 = u8"true"_toml;
        const toml::value v2 = u8"false"_toml;
@@ -262,18 +98,15 @@ BOOST_AUTO_TEST_CASE(test_value_as_u8_literal)
        const toml::value v2 = u8R"('foo')"_toml;
        const toml::value v3 = u8R"("""foo""")"_toml;
        const toml::value v4 = u8R"('''foo''')"_toml;
-        const toml::value v5 = u8R"("ひらがな")"_toml;

        BOOST_TEST(v1.is_string());
        BOOST_TEST(v2.is_string());
        BOOST_TEST(v3.is_string());
        BOOST_TEST(v4.is_string());
-        BOOST_TEST(v5.is_string());
        BOOST_TEST(toml::get<std::string>(v1) == "foo");
        BOOST_TEST(toml::get<std::string>(v2) == "foo");
        BOOST_TEST(toml::get<std::string>(v3) == "foo");
        BOOST_TEST(toml::get<std::string>(v4) == "foo");
-        BOOST_TEST(toml::get<std::string>(v5) == "\xE3\x81\xB2\xE3\x82\x89\xE3\x81\x8C\xE3\x81\xAA");
    }
    {
        {
@@ -331,7 +164,7 @@ BOOST_AUTO_TEST_CASE(test_value_as_u8_literal)
                                 toml::local_time(7, 32, 0)));
    }
    {
-        const toml::value v1 = u8"1979-05-27T07:32:00Z"_toml;
+        const toml::value v1 = "1979-05-27T07:32:00Z"_toml;
        BOOST_TEST(v1.is_offset_datetime());
        BOOST_TEST(toml::get<toml::offset_datetime>(v1) ==
            toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
--- a/tests/test_parse_array.cpp
+++ b/tests/test_parse_array.cpp
@@ -172,18 +172,3 @@ BOOST_AUTO_TEST_CASE(test_heterogeneous_array)
    }
 #endif
 }
-
-BOOST_AUTO_TEST_CASE(test_comments_after_comma)
-{
-    {
-        array a;
-        a.push_back("foo");
-        a.push_back("bar");
-        a.push_back("baz");
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-            "[ \"foo\" # comment\n"
-            ", \"bar\" # comment\n"
-            ", \"baz\" # comment\n"
-            "]", toml::value(a));
-    }
-}
--- a/tests/test_parse_aux.hpp
+++ b/tests/test_parse_aux.hpp
@@ -7,7 +7,7 @@
 #define TOML11_TEST_PARSE_EQUAL(psr, tkn, expct)                               \
 do {                                                                           \
    const std::string token(tkn);                                              \
-    toml::detail::location loc("test", token);                                 \
+    toml::detail::location<std::string> loc("test", token);                    \
    const auto result = psr(loc);                                              \
    BOOST_TEST(result.is_ok());                                                \
    if(result.is_ok()){                                                        \
@@ -23,7 +23,7 @@ do {                                                                           \
 #define TOML11_TEST_PARSE_EQUAL_VALUE(psr, tkn, expct)                         \
 do {                                                                           \
    const std::string token(tkn);                                              \
-    toml::detail::location loc("test", token);                                 \
+    toml::detail::location<std::string> loc("test", token);                    \
    const auto result = psr(loc);                                              \
    BOOST_TEST(result.is_ok());                                                \
    if(result.is_ok()){                                                        \
--- a/tests/test_parse_file.cpp
+++ b/tests/test_parse_file.cpp
@@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE(test_example)

 BOOST_AUTO_TEST_CASE(test_example_stream)
 {
-    std::ifstream ifs("toml/tests/example.toml", std::ios::binary);
+    std::ifstream ifs("toml/tests/example.toml");
    const auto data = toml::parse(ifs);

    BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
@@ -779,22 +779,6 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
        BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
    }

-    // without newline
-    {
-        const std::string table(
-            "key = \"value\"\n"
-            "[table]\n"
-            "key = \"value\"\n"
-            "a = 0"
-            );
-        std::istringstream iss(table);
-        const auto data = toml::parse(iss,
-                "test_files_end_with_newline.toml");
-
-        BOOST_TEST(toml::find<std::string>(data, "key") == "value");
-        BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
-    }
-

    // CRLF

@@ -905,41 +889,3 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
    }
 }

-
-BOOST_AUTO_TEST_CASE(test_parse_function_compiles)
-{
-    // toml::parse("");
-    const auto string_literal = toml::parse("toml/tests/example.toml");
-
-    BOOST_TEST_MESSAGE("string_literal");
-
-    const char* fname_cstring = "toml/tests/example.toml";
-    // toml::parse(const char*);
-    const auto cstring = toml::parse(fname_cstring);
-
-    BOOST_TEST_MESSAGE("const char*");
-
-    // toml::parse(char*);
-    std::array<char, 24> fname_char_ptr;
-    std::strncpy(fname_char_ptr.data(), fname_cstring, 24);
-    const auto char_ptr = toml::parse(fname_char_ptr.data());
-
-    BOOST_TEST_MESSAGE("char*");
-
-    // toml::parse(const std::string&);
-    const std::string fname_string("toml/tests/example.toml");
-    const auto string = toml::parse(fname_string);
-    std::string fname_string_mut("toml/tests/example.toml");
-    // toml::parse(std::string&);
-    const auto string_mutref = toml::parse(fname_string_mut);
-    // toml::parse(std::string&&);
-    const auto string_rref = toml::parse(std::move(fname_string_mut));
-
-    BOOST_TEST_MESSAGE("strings");
-
-#ifdef TOML11_HAS_STD_FILESYSTEM
-    const std::filesystem::path fname_path(fname_string.begin(), fname_string.end());
-    const auto filesystem_path = toml::parse(fname_path);
-    BOOST_TEST_MESSAGE("path");
-#endif
-}
--- a/tests/test_parse_floating.cpp
+++ b/tests/test_parse_floating.cpp
@@ -128,7 +128,7 @@ BOOST_AUTO_TEST_CASE(test_inf)
 {
    {
        const std::string token("inf");
-        toml::detail::location loc("test", token);
+        toml::detail::location<std::string> loc("test", token);
        const auto r = parse_floating(loc);
        BOOST_CHECK(r.is_ok());
        BOOST_CHECK(std::isinf(r.unwrap().first));
@@ -136,7 +136,7 @@ BOOST_AUTO_TEST_CASE(test_inf)
    }
    {
        const std::string token("+inf");
-        toml::detail::location loc("test", token);
+        toml::detail::location<std::string> loc("test", token);
        const auto r = parse_floating(loc);
        BOOST_CHECK(r.is_ok());
        BOOST_CHECK(std::isinf(r.unwrap().first));
@@ -144,7 +144,7 @@ BOOST_AUTO_TEST_CASE(test_inf)
    }
    {
        const std::string token("-inf");
-        toml::detail::location loc("test", token);
+        toml::detail::location<std::string> loc("test", token);
        const auto r = parse_floating(loc);
        BOOST_CHECK(r.is_ok());
        BOOST_CHECK(std::isinf(r.unwrap().first));
@@ -156,21 +156,21 @@ BOOST_AUTO_TEST_CASE(test_nan)
 {
    {
        const std::string token("nan");
-        toml::detail::location loc("test", token);
+        toml::detail::location<std::string> loc("test", token);
        const auto r = parse_floating(loc);
        BOOST_CHECK(r.is_ok());
        BOOST_CHECK(std::isnan(r.unwrap().first));
    }
    {
        const std::string token("+nan");
-        toml::detail::location loc("test", token);
+        toml::detail::location<std::string> loc("test", token);
        const auto r = parse_floating(loc);
        BOOST_CHECK(r.is_ok());
        BOOST_CHECK(std::isnan(r.unwrap().first));
    }
    {
        const std::string token("-nan");
-        toml::detail::location loc("test", token);
+        toml::detail::location<std::string> loc("test", token);
        const auto r = parse_floating(loc);
        BOOST_CHECK(r.is_ok());
        BOOST_CHECK(std::isnan(r.unwrap().first));
--- a/tests/test_parse_string.cpp
+++ b/tests/test_parse_string.cpp
@@ -29,16 +29,16 @@ BOOST_AUTO_TEST_CASE(test_string)

 BOOST_AUTO_TEST_CASE(test_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"The quick brown fox jumps over the lazy dog\"",
        toml::value("The quick brown fox jumps over the lazy dog", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\'The quick brown fox jumps over the lazy dog\'",
        toml::value("The quick brown fox jumps over the lazy dog", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"\"\"The quick brown fox \\\njumps over the lazy dog\"\"\"",
        toml::value("The quick brown fox jumps over the lazy dog", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "'''The quick brown fox \njumps over the lazy dog'''",
        toml::value("The quick brown fox \njumps over the lazy dog", string_t::literal));
 }
@@ -69,17 +69,14 @@ BOOST_AUTO_TEST_CASE(test_basic_string)
    TOML11_TEST_PARSE_EQUAL(parse_string,
        "\" And when \\\"'s are in the along with # \\\"\"",
        string(" And when \"'s are in the along with # \"", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "\"Here are fifteen apostrophes: '''''''''''''''\"",
-        string("Here are fifteen apostrophes: '''''''''''''''", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_basic_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"GitHub Cofounder & CEO\\nLikes tater tots and beer.\"",
        value("GitHub Cofounder & CEO\nLikes tater tots and beer.", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"192.168.1.1\"",
        value("192.168.1.1", string_t::basic));
 #if defined(_MSC_VER) || defined(__INTEL_COMPILER)
@@ -87,19 +84,16 @@ BOOST_AUTO_TEST_CASE(test_basic_string_value)
        "\"\xE4\xB8\xAD\xE5\x9B\xBD\"",
        value("\xE4\xB8\xAD\xE5\x9B\xBD", string_t::basic));
 #else
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"中国\"",
        value("中国", string_t::basic));
 #endif
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"You'll hate me after this - #\"",
        value("You'll hate me after this - #", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\" And when \\\"'s are in the along with # \\\"\"",
        value(" And when \"'s are in the along with # \"", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "\"Here are fifteen apostrophes: '''''''''''''''\"",
-        value("Here are fifteen apostrophes: '''''''''''''''", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_ml_basic_string)
@@ -110,41 +104,16 @@ BOOST_AUTO_TEST_CASE(test_ml_basic_string)
    TOML11_TEST_PARSE_EQUAL(parse_string,
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"",
        string("The quick brown fox jumps over the lazy dog.", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"",
-        string("Here are two quotation marks: \"\". Simple enough.", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"",
-        string("Here are three quotation marks: \"\"\".", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"",
-        string("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"",
-        string("\"This,\" she said, \"is just a pointless statement.\"", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_ml_basic_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"\"\"\nThe quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\"\"\"",
        value("The quick brown fox jumps over the lazy dog.", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"",
        value("The quick brown fox jumps over the lazy dog.", string_t::basic));
-
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"",
-        value("Here are two quotation marks: \"\". Simple enough.", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"",
-        value("Here are three quotation marks: \"\"\".", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"",
-        value("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"",
-        value("\"This,\" she said, \"is just a pointless statement.\"", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_literal_string)
@@ -165,16 +134,16 @@ BOOST_AUTO_TEST_CASE(test_literal_string)

 BOOST_AUTO_TEST_CASE(test_literal_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "'C:\\Users\\nodejs\\templates'",
        value("C:\\Users\\nodejs\\templates", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "'\\\\ServerX\\admin$\\system32\\'",
        value("\\\\ServerX\\admin$\\system32\\", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "'Tom \"Dubs\" Preston-Werner'",
        value("Tom \"Dubs\" Preston-Werner", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "'<\\i\\c*\\s*>'",
        value("<\\i\\c*\\s*>", string_t::literal));
 }
@@ -187,34 +156,16 @@ BOOST_AUTO_TEST_CASE(test_ml_literal_string)
    TOML11_TEST_PARSE_EQUAL(parse_string,
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''",
        string("The first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "''''That's still pointless', she said.'''",
-        string("'That's still pointless', she said.", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''",
-        string("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL(parse_string,
-        "''''This,' she said, 'is just a pointless statement.''''",
-        string("'This,' she said, 'is just a pointless statement.'", string_t::literal));
 }

 BOOST_AUTO_TEST_CASE(test_ml_literal_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "'''I [dw]on't need \\d{2} apples'''",
        value("I [dw]on't need \\d{2} apples", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''",
        value("The first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "''''That's still pointless', she said.'''",
-        value("'That's still pointless', she said.", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''",
-        value("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
-        "''''This,' she said, 'is just a pointless statement.''''",
-        value("'This,' she said, 'is just a pointless statement.'", string_t::literal));
 }

 BOOST_AUTO_TEST_CASE(test_unicode_escape_sequence)
--- a/tests/test_parse_table.cpp
+++ b/tests/test_parse_table.cpp
@@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE(test_normal_table)
        "key2 = 42\n"
        "key3 = 3.14\n"
        );
-    location loc("test", table);
+    location<std::string> loc("test", table);

    const auto result = toml::detail::parse_ml_table<toml::value>(loc);
    BOOST_TEST(result.is_ok());
@@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE(test_nested_table)
        "a.b   = \"value\"\n"
        "a.c.d = 42\n"
        );
-    location loc("test", table);
+    location<std::string> loc("test", table);

    const auto result = toml::detail::parse_ml_table<toml::value>(loc);
    BOOST_TEST(result.is_ok());
--- a/tests/test_parse_unicode.cpp
+++ b/tests/test_parse_unicode.cpp
@@ -9,6 +9,7 @@
 #include <iostream>
 #include <fstream>

+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
 BOOST_AUTO_TEST_CASE(test_hard_example_unicode)
 {
    const auto data = toml::parse("toml/tests/hard_example_unicode.toml");
@@ -39,3 +40,35 @@ BOOST_AUTO_TEST_CASE(test_hard_example_unicode)
    BOOST_CHECK(toml::get<std::vector<std::string>>(bit.at("multi_line_array")) ==
                expected_multi_line_array);
 }
+#else
+BOOST_AUTO_TEST_CASE(test_hard_example_unicode)
+{
+    const auto data = toml::parse("toml/tests/hard_example_unicode.toml");
+
+    const auto the = toml::find<toml::table>(data, "the");
+    BOOST_TEST(toml::get<std::string>(the.at("test_string")) ==
+                      std::string(u8"Ýôú'ℓℓ λáƭè ₥è áƒƭèř ƭλïƨ - #"));
+
+    const auto hard = toml::get<toml::table>(the.at("hard"));
+    const std::vector<std::string> expected_the_hard_test_array{"] ", " # "};
+    BOOST_CHECK(toml::get<std::vector<std::string>>(hard.at("test_array")) ==
+                expected_the_hard_test_array);
+    const std::vector<std::string> expected_the_hard_test_array2{
+            std::string(u8"Tèƨƭ #11 ]ƥřôƲèδ ƭλáƭ"),
+            std::string(u8"Éжƥèřï₥èñƭ #9 ωáƨ á ƨúççèƨƨ")};
+    BOOST_CHECK(toml::get<std::vector<std::string>>(hard.at("test_array2")) ==
+                expected_the_hard_test_array2);
+    BOOST_TEST(toml::get<std::string>(hard.at("another_test_string")) ==
+                      std::string(u8"§á₥è ƭλïñϱ, βúƭ ωïƭλ á ƨƭřïñϱ #"));
+    BOOST_TEST(toml::get<std::string>(hard.at("harder_test_string")) ==
+                      std::string(u8" Âñδ ωλèñ \"'ƨ ářè ïñ ƭλè ƨƭřïñϱ, áℓôñϱ ωïƭλ # \""));
+
+    const auto bit = toml::get<toml::table>(hard.at(std::string(u8"βïƭ#")));
+    BOOST_TEST(toml::get<std::string>(bit.at(std::string(u8"ωλáƭ?"))) ==
+                      std::string(u8"Ýôú δôñ'ƭ ƭλïñƙ ƨô₥è úƨèř ωôñ'ƭ δô ƭλáƭ?"));
+    const std::vector<std::string> expected_multi_line_array{"]"};
+    BOOST_CHECK(toml::get<std::vector<std::string>>(bit.at("multi_line_array")) ==
+                expected_multi_line_array);
+
+}
+#endif
--- a/tests/test_utility.cpp
+++ b/tests/test_utility.cpp
@@ -9,24 +9,27 @@
 #include <vector>
 #include <array>

-BOOST_AUTO_TEST_CASE(test_try_reserve)
+BOOST_AUTO_TEST_CASE(test_resize)
 {
    {
-        // since BOOST_TEST is a macro, it cannot handle commas correctly.
-        // When toml::detail::has_reserve_method<std::array<int, 1>>::value
-        // is passed to a macro, C preprocessor considers
-        // toml::detail::has_reserve_method<std::array<int as the first argument
-        // and 1>>::value as the second argument. We need an alias to avoid
-        // this problem.
-        using reservable_type    = std::vector<int>  ;
-        using nonreservable_type = std::array<int, 1>;
-        BOOST_TEST( toml::detail::has_reserve_method<reservable_type   >::value);
-        BOOST_TEST(!toml::detail::has_reserve_method<nonreservable_type>::value);
+        typedef std::vector<int>  resizable_type;
+        typedef std::array<int,1> non_resizable_type;
+        BOOST_TEST(toml::detail::has_resize_method<resizable_type>::value);
+        BOOST_TEST(!toml::detail::has_resize_method<non_resizable_type>::value);
    }
    {
        std::vector<int> v;
-        toml::try_reserve(v, 100);
-        BOOST_TEST(v.capacity() == 100u);
+        toml::resize(v, 10);
+        BOOST_TEST(v.size() == 10u);
+    }
+    {
+        std::array<int, 15> a;
+        toml::resize(a, 10);
+        BOOST_TEST(a.size() == 15u);
+    }
+    {
+        std::array<int, 15> a;
+        BOOST_CHECK_THROW(toml::resize(a, 20), std::invalid_argument);
    }
 }

--- a/tests/test_visit.cpp
+++ b/tests/test_visit.cpp
@@ -0,0 +1,172 @@
+#define BOOST_TEST_MODULE "test_visit"
+#ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST
+#include <boost/test/unit_test.hpp>
+#else
+#define BOOST_TEST_NO_LIB
+#include <boost/test/included/unit_test.hpp>
+#endif
+
+#include <toml.hpp>
+#include <map>
+#include <deque>
+
+using test_value_types = std::tuple<
+    toml::value,
+    toml::basic_value<toml::preserve_comments>,
+    toml::basic_value<toml::discard_comments,  std::map, std::deque>,
+    toml::basic_value<toml::preserve_comments, std::map, std::deque>
+>;
+
+template<typename Value>
+struct visitor1
+{
+    std::string operator()(const toml::boolean&)              const {return "boolean";}
+    std::string operator()(const toml::integer&)              const {return "integer";}
+    std::string operator()(const toml::floating&)             const {return "floating";}
+    std::string operator()(const toml::string&)               const {return "string";}
+    std::string operator()(const toml::local_time&)           const {return "local_time";}
+    std::string operator()(const toml::local_date&)           const {return "local_date";}
+    std::string operator()(const toml::local_datetime&)       const {return "local_datetime";}
+    std::string operator()(const toml::offset_datetime&)      const {return "offset_datetime";}
+    std::string operator()(const typename Value::array_type&) const {return "array";}
+    std::string operator()(const typename Value::table_type&) const {return "table";}
+};
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_visit_one, value_type, test_value_types)
+{
+    {
+        const value_type v(true);
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "boolean");
+    }
+    {
+        const value_type v(42);
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "integer");
+    }
+    {
+        const value_type v(3.14);
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "floating");
+    }
+    {
+        const value_type v("foo");
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "string");
+    }
+    {
+        const value_type v(toml::local_date(2018, toml::month_t::Apr, 22));
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "local_date");
+    }
+    {
+        const value_type v(toml::local_time(12, 34, 56));
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "local_time");
+    }
+    {
+        const value_type v(toml::local_datetime(
+                    toml::local_date(2018, toml::month_t::Apr, 22),
+                    toml::local_time(12, 34, 56)));
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "local_datetime");
+    }
+    {
+        const value_type v(toml::offset_datetime(
+                    toml::local_date(2018, toml::month_t::Apr, 22),
+                    toml::local_time(12, 34, 56),
+                    toml::time_offset(9, 0)));
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "offset_datetime");
+    }
+    {
+        const value_type v{1,2,3,4,5};
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "array");
+    }
+    {
+        const value_type v{
+            {"foo", 42}, {"bar", "baz"}
+        };
+        BOOST_TEST(toml::visit(visitor1<value_type>{}, v) == "table");
+    }
+}
+
+template<typename Value>
+struct visitor2
+{
+    template<typename T1, typename T2>
+    std::string operator()(const T1& v1, const T2& v2) const
+    {
+        visitor1<Value> vis;
+        return vis(v1) + "+" + vis(v2);
+    }
+};
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_visit_two, value_type, test_value_types)
+{
+    std::vector<value_type> vs;
+    vs.push_back(value_type(true));
+    vs.push_back(value_type(42));
+    vs.push_back(value_type(3.14));
+    vs.push_back(value_type("foo"));
+    vs.push_back(value_type(toml::local_date(2018, toml::month_t::Apr, 22)));
+    vs.push_back(value_type(toml::local_time(12, 34, 56)));
+    vs.push_back(value_type(toml::local_datetime(
+                                toml::local_date(2018, toml::month_t::Apr, 22),
+                                toml::local_time(12, 34, 56))));
+    vs.push_back(value_type(toml::offset_datetime(
+                                toml::local_date(2018, toml::month_t::Apr, 22),
+                                toml::local_time(12, 34, 56),
+                                toml::time_offset(9, 0))));
+    vs.push_back(value_type{1,2,3,4,5});
+    vs.push_back(value_type{{"foo", 42}, {"bar", "baz"}});
+
+    for(const auto& v1 : vs)
+    {
+        const auto t1 = toml::visit(visitor1<value_type>{}, v1);
+        for(const auto& v2 : vs)
+        {
+            const auto t2 = toml::visit(visitor1<value_type>{}, v2);
+            BOOST_TEST(toml::visit(visitor2<value_type>{}, v1, v2) ==
+                       t1 + "+" + t2);
+        }
+    }
+}
+
+template<typename Value>
+struct visitor3
+{
+    template<typename T1, typename T2, typename T3>
+    std::string operator()(const T1& v1, const T2& v2, const T3& v3) const
+    {
+        visitor1<Value> vis;
+        return vis(v1) + "+" + vis(v2) + "+" + vis(v3);
+    }
+};
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_visit_three, value_type, test_value_types)
+{
+    std::vector<value_type> vs;
+    vs.push_back(value_type(true));
+    vs.push_back(value_type(42));
+    vs.push_back(value_type(3.14));
+    vs.push_back(value_type("foo"));
+    vs.push_back(value_type(toml::local_date(2018, toml::month_t::Apr, 22)));
+    vs.push_back(value_type(toml::local_time(12, 34, 56)));
+    vs.push_back(value_type(toml::local_datetime(
+                                toml::local_date(2018, toml::month_t::Apr, 22),
+                                toml::local_time(12, 34, 56))));
+    vs.push_back(value_type(toml::offset_datetime(
+                                toml::local_date(2018, toml::month_t::Apr, 22),
+                                toml::local_time(12, 34, 56),
+                                toml::time_offset(9, 0))));
+    vs.push_back(value_type{1,2,3,4,5});
+    vs.push_back(value_type{{"foo", 42}, {"bar", "baz"}});
+
+    for(const auto& v1 : vs)
+    {
+        const auto t1 = toml::visit(visitor1<value_type>{}, v1);
+        for(const auto& v2 : vs)
+        {
+            const auto t2 = toml::visit(visitor1<value_type>{}, v2);
+            for(const auto& v3 : vs)
+            {
+                const auto t3 = toml::visit(visitor1<value_type>{}, v3);
+                BOOST_TEST(toml::visit(visitor3<value_type>{}, v1, v2, v3) ==
+                           t1 + "+" + t2 + "+" + t3);
+            }
+        }
+    }
+}
--- a/tests/test_windows.cpp
+++ b/tests/test_windows.cpp
@@ -1,12 +0,0 @@
-#include <windows.h>
-#include <toml.hpp>
-#include <iostream>
-
-int main()
-{
-    using namespace toml::literals::toml_literals;
-    const auto data = R"(windows = "defines min and max as a macro")"_toml;
-
-    std::cout << toml::find<std::string>(data, "windows") << std::endl;
-    return 0;
-}
--- a/toml.hpp
+++ b/toml.hpp
@@ -33,10 +33,6 @@
 #    error "toml11 requires C++11 or later."
 #endif

-#define TOML11_VERSION_MAJOR 3
-#define TOML11_VERSION_MINOR 5
-#define TOML11_VERSION_PATCH 0
-
 #include "toml/parser.hpp"
 #include "toml/literal.hpp"
 #include "toml/serializer.hpp"
--- a/toml/color.hpp
+++ b/toml/color.hpp
@@ -1,7 +1,7 @@
 #ifndef TOML11_COLOR_HPP
 #define TOML11_COLOR_HPP
-#include <cstdint>
 #include <ostream>
+#include <cstdint>

 #ifdef TOML11_COLORIZE_ERROR_MESSAGE
 #define TOML11_ERROR_MESSAGE_COLORIZED true
--- a/toml/combinator.hpp
+++ b/toml/combinator.hpp
@@ -2,20 +2,18 @@
 // Distributed under the MIT License.
 #ifndef TOML11_COMBINATOR_HPP
 #define TOML11_COMBINATOR_HPP
-#include <cassert>
-#include <cctype>
-#include <cstdio>
-
-#include <array>
-#include <iomanip>
+#include "traits.hpp"
+#include "result.hpp"
+#include "utility.hpp"
+#include "region.hpp"
+#include <type_traits>
 #include <iterator>
 #include <limits>
-#include <type_traits>
-
-#include "region.hpp"
-#include "result.hpp"
-#include "traits.hpp"
-#include "utility.hpp"
+#include <array>
+#include <iomanip>
+#include <cstdio>
+#include <cassert>
+#include <cctype>

 // they scans characters and returns region if it matches to the condition.
 // when they fail, it does not change the location.
@@ -58,9 +56,13 @@ struct character
 {
    static constexpr char target = C;

-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
+        static_assert(std::is_same<char, typename Cont::value_type>::value,
+                      "internal error: container::value_type should be `char`.");
+
        if(loc.iter() == loc.end()) {return none();}
        const auto first = loc.iter();

@@ -71,7 +73,7 @@ struct character
        }
        loc.advance(); // update location

-        return ok(region(loc, first, loc.iter()));
+        return ok(region<Cont>(loc, first, loc.iter()));
    }
 };
 template<char C>
@@ -87,9 +89,13 @@ struct in_range
    static constexpr char upper = Up;
    static constexpr char lower = Low;

-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
+        static_assert(std::is_same<char, typename Cont::value_type>::value,
+                      "internal error: container::value_type should be `char`.");
+
        if(loc.iter() == loc.end()) {return none();}
        const auto first = loc.iter();

@@ -100,7 +106,7 @@ struct in_range
        }

        loc.advance();
-        return ok(region(loc, first, loc.iter()));
+        return ok(region<Cont>(loc, first, loc.iter()));
    }
 };
 template<char L, char U> constexpr char in_range<L, U>::upper;
@@ -111,9 +117,13 @@ template<char L, char U> constexpr char in_range<L, U>::lower;
 template<typename Combinator>
 struct exclude
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
+        static_assert(std::is_same<char, typename Cont::value_type>::value,
+                      "internal error: container::value_type should be `char`.");
+
        if(loc.iter() == loc.end()) {return none();}
        auto first = loc.iter();

@@ -124,7 +134,7 @@ struct exclude
            return none();
        }
        loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but...
-        return ok(region(loc, first, loc.iter()));
+        return ok(region<Cont>(loc, first, loc.iter()));
    }
 };

@@ -132,15 +142,19 @@ struct exclude
 template<typename Combinator>
 struct maybe
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
+        static_assert(std::is_same<char, typename Cont::value_type>::value,
+                      "internal error: container::value_type should be `char`.");
+
        const auto rslt = Combinator::invoke(loc);
        if(rslt.is_ok())
        {
            return rslt;
        }
-        return ok(region(loc));
+        return ok(region<Cont>(loc));
    }
 };

@@ -150,9 +164,13 @@ struct sequence;
 template<typename Head, typename ... Tail>
 struct sequence<Head, Tail...>
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
+        static_assert(std::is_same<char, typename Cont::value_type>::value,
+                      "internal error: container::value_type should be `char`.");
+
        const auto first = loc.iter();
        const auto rslt = Head::invoke(loc);
        if(rslt.is_err())
@@ -164,9 +182,9 @@ struct sequence<Head, Tail...>
    }

    // called from the above function only, recursively.
-    template<typename Iterator>
-    static result<region, none_t>
-    invoke(location& loc, region reg, Iterator first)
+    template<typename Cont, typename Iterator>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
    {
        const auto rslt = Head::invoke(loc);
        if(rslt.is_err())
@@ -183,9 +201,9 @@ template<typename Head>
 struct sequence<Head>
 {
    // would be called from sequence<T ...>::invoke only.
-    template<typename Iterator>
-    static result<region, none_t>
-    invoke(location& loc, region reg, Iterator first)
+    template<typename Cont, typename Iterator>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
    {
        const auto rslt = Head::invoke(loc);
        if(rslt.is_err())
@@ -204,9 +222,13 @@ struct either;
 template<typename Head, typename ... Tail>
 struct either<Head, Tail...>
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
+        static_assert(std::is_same<char, typename Cont::value_type>::value,
+                      "internal error: container::value_type should be `char`.");
+
        const auto rslt = Head::invoke(loc);
        if(rslt.is_ok()) {return rslt;}
        return either<Tail...>::invoke(loc);
@@ -215,9 +237,12 @@ struct either<Head, Tail...>
 template<typename Head>
 struct either<Head>
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
+        static_assert(std::is_same<char, typename Cont::value_type>::value,
+                      "internal error: container::value_type should be `char`.");
        return Head::invoke(loc);
    }
 };
@@ -232,10 +257,11 @@ struct unlimited{};
 template<typename T, std::size_t N>
 struct repeat<T, exactly<N>>
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
-        region retval(loc);
+        region<Cont> retval(loc);
        const auto first = loc.iter();
        for(std::size_t i=0; i<N; ++i)
        {
@@ -254,10 +280,11 @@ struct repeat<T, exactly<N>>
 template<typename T, std::size_t N>
 struct repeat<T, at_least<N>>
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
-        region retval(loc);
+        region<Cont> retval(loc);

        const auto first = loc.iter();
        for(std::size_t i=0; i<N; ++i)
@@ -285,10 +312,11 @@ struct repeat<T, at_least<N>>
 template<typename T>
 struct repeat<T, unlimited>
 {
-    static result<region, none_t>
-    invoke(location& loc)
+    template<typename Cont>
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
    {
-        region retval(loc);
+        region<Cont> retval(loc);
        while(true)
        {
            auto rslt = T::invoke(loc);
--- a/toml/comments.hpp
+++ b/toml/comments.hpp
@@ -2,12 +2,12 @@
 // Distributed under the MIT License.
 #ifndef TOML11_COMMENTS_HPP
 #define TOML11_COMMENTS_HPP
-#include <initializer_list>
-#include <iterator>
-#include <string>
 #include <type_traits>
 #include <utility>
+#include <iterator>
+#include <initializer_list>
 #include <vector>
+#include <string>

 // This file provides mainly two classes, `preserve_comments` and `discard_comments`.
 // Those two are a container that have the same interface as `std::vector<std::string>`
@@ -81,54 +81,6 @@ struct preserve_comments
    void assign(std::initializer_list<std::string> ini)  {comments.assign(ini);}
    void assign(size_type n, const std::string& val)     {comments.assign(n, val);}

-    // Related to the issue #97.
-    //
-    // It is known that `std::vector::insert` and `std::vector::erase` in
-    // the standard library implementation included in GCC 4.8.5 takes
-    // `std::vector::iterator` instead of `std::vector::const_iterator`.
-    // Because of the const-correctness, we cannot convert a `const_iterator` to
-    // an `iterator`. It causes compilation error in GCC 4.8.5.
-#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) && !defined(__clang__)
-#  if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) <= 40805
-#    define TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION
-#  endif
-#endif
-
-#ifdef TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION
-    iterator insert(iterator p, const std::string& x)
-    {
-        return comments.insert(p, x);
-    }
-    iterator insert(iterator p, std::string&&      x)
-    {
-        return comments.insert(p, std::move(x));
-    }
-    void insert(iterator p, size_type n, const std::string& x)
-    {
-        return comments.insert(p, n, x);
-    }
-    template<typename InputIterator>
-    void insert(iterator p, InputIterator first, InputIterator last)
-    {
-        return comments.insert(p, first, last);
-    }
-    void insert(iterator p, std::initializer_list<std::string> ini)
-    {
-        return comments.insert(p, ini);
-    }
-
-    template<typename ... Ts>
-    iterator emplace(iterator p, Ts&& ... args)
-    {
-        return comments.emplace(p, std::forward<Ts>(args)...);
-    }
-
-    iterator erase(iterator pos) {return comments.erase(pos);}
-    iterator erase(iterator first, iterator last)
-    {
-        return comments.erase(first, last);
-    }
-#else
    iterator insert(const_iterator p, const std::string& x)
    {
        return comments.insert(p, x);
@@ -162,7 +114,6 @@ struct preserve_comments
    {
        return comments.erase(first, last);
    }
-#endif

    void swap(preserve_comments& other) {comments.swap(other.comments);}

--- a/toml/datetime.hpp
+++ b/toml/datetime.hpp
@@ -2,16 +2,15 @@
 // Distributed under the MIT License.
 #ifndef TOML11_DATETIME_HPP
 #define TOML11_DATETIME_HPP
+#include <chrono>
+#include <tuple>
+#include <array>
+#include <ostream>
+#include <iomanip>
 #include <cstdint>
 #include <cstdlib>
 #include <ctime>

-#include <array>
-#include <chrono>
-#include <iomanip>
-#include <ostream>
-#include <tuple>
-
 namespace toml
 {

@@ -21,7 +20,7 @@ namespace toml
 namespace detail
 {
 // TODO: find more sophisticated way to handle this
-#if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || defined(_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;
@@ -36,7 +35,7 @@ inline std::tm gmtime_s(const std::time_t* src)
    if (!result) { throw std::runtime_error("gmtime_r failed."); }
    return dst;
 }
-#elif defined(_MSC_VER)
+#elif _MSC_VER
 inline std::tm localtime_s(const std::time_t* src)
 {
    std::tm dst;
--- a/toml/exception.hpp
+++ b/toml/exception.hpp
@@ -2,11 +2,10 @@
 // Distributed under the MIT License.
 #ifndef TOML11_EXCEPTION_HPP
 #define TOML11_EXCEPTION_HPP
+#include "source_location.hpp"
 #include <stdexcept>
 #include <string>

-#include "source_location.hpp"
-
 namespace toml
 {

--- a/toml/get.hpp
+++ b/toml/get.hpp
@@ -2,11 +2,10 @@
 // Distributed under the MIT License.
 #ifndef TOML11_GET_HPP
 #define TOML11_GET_HPP
-#include <algorithm>
-
 #include "from.hpp"
 #include "result.hpp"
 #include "value.hpp"
+#include <algorithm>

 namespace toml
 {
@@ -189,7 +188,8 @@ get(const basic_value<C, M, V>& v)
        {
            throw type_error(detail::format_underline("toml::value: "
                "bad_cast to std::chrono::system_clock::time_point", {
-                    {v.location(), concat_to_string("the actual type is ", v.type())}
+                    {std::addressof(detail::get_region(v)),
+                     concat_to_string("the actual type is ", v.type())}
                }), v.location());
        }
    }
@@ -198,24 +198,24 @@ get(const basic_value<C, M, V>& v)
 // ============================================================================
 // forward declaration to use this recursively. ignore this and go ahead.

-// array-like type with push_back(value) method
+// array-like type with resize(N) method
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
-    detail::is_container<T>,         // T is a container
-    detail::has_push_back_method<T>, // T::push_back(value) works
-    detail::negation<                // but not toml::array
+    detail::is_container<T>,      // T is container
+    detail::has_resize_method<T>, // T::resize(N) works
+    detail::negation<             // but not toml::array
        detail::is_exact_toml_type<T, basic_value<C, M, V>>>
    >::value, T>
 get(const basic_value<C, M, V>&);

-// array-like type without push_back(value) method
+// array-like type with resize(N) method
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
-    detail::is_container<T>,                           // T is a container
-    detail::negation<detail::has_push_back_method<T>>, // w/o push_back(...)
-    detail::negation<                                  // not toml::array
+    detail::is_container<T>,                        // T is container
+    detail::negation<detail::has_resize_method<T>>, // no T::resize() exists
+    detail::negation<                               // not toml::array
        detail::is_exact_toml_type<T, basic_value<C, M, V>>>
    >::value, T>
 get(const basic_value<C, M, V>&);
@@ -274,54 +274,31 @@ get(const basic_value<C, M, V>&);
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
-    detail::is_container<T>,         // T is a container
-    detail::has_push_back_method<T>, // container.push_back(elem) works
-    detail::negation<                // but not toml::array
+    detail::is_container<T>,      // T is container
+    detail::has_resize_method<T>, // T::resize(N) works
+    detail::negation<             // but not toml::array
        detail::is_exact_toml_type<T, basic_value<C, M, V>>>
    >::value, T>
 get(const basic_value<C, M, V>& v)
 {
    using value_type = typename T::value_type;
-    const auto& ary = v.as_array();
-
+    const auto& ar = v.as_array();
    T container;
-    try_reserve(container, ary.size());
-
-    for(const auto& elem : ary)
-    {
-        container.push_back(get<value_type>(elem));
-    }
+    container.resize(ar.size());
+    std::transform(ar.cbegin(), ar.cend(), container.begin(),
+                   [](const value& x){return ::toml::get<value_type>(x);});
    return container;
 }

 // ============================================================================
-// std::forward_list does not have push_back, insert, or emplace.
-// It has insert_after, emplace_after, push_front.
-
-template<typename T, typename C,
-         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<detail::is_std_forward_list<T>::value, T>
-get(const basic_value<C, M, V>& v)
-{
-    using value_type = typename T::value_type;
-    T container;
-    for(const auto& elem : v.as_array())
-    {
-        container.push_front(get<value_type>(elem));
-    }
-    container.reverse();
-    return container;
-}
-
-// ============================================================================
-// array-like types, without push_back(). most likely [std|boost]::array.
+// array-like types; but does not have resize(); most likely std::array.

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
-    detail::is_container<T>,                           // T is a container
-    detail::negation<detail::has_push_back_method<T>>, // w/o push_back
-    detail::negation<                                  // T is not toml::array
+    detail::is_container<T>,                        // T is container
+    detail::negation<detail::has_resize_method<T>>, // no T::resize() exists
+    detail::negation<                              // but not toml::array
        detail::is_exact_toml_type<T, basic_value<C, M, V>>>
    >::value, T>
 get(const basic_value<C, M, V>& v)
@@ -335,7 +312,7 @@ get(const basic_value<C, M, V>& v)
        throw std::out_of_range(detail::format_underline(concat_to_string(
            "toml::get: specified container size is ", container.size(),
            " but there are ", ar.size(), " elements in toml array."), {
-                {v.location(), "here"}
+                {std::addressof(detail::get_region(v)), "here"}
            }));
    }
    std::transform(ar.cbegin(), ar.cend(), container.begin(),
@@ -359,7 +336,9 @@ get(const basic_value<C, M, V>& v)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
            "toml::get: specified std::pair but there are ", ar.size(),
-            " elements in toml array."), {{v.location(), "here"}}));
+            " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
    }
    return std::make_pair(::toml::get<first_type >(ar.at(0)),
                          ::toml::get<second_type>(ar.at(1)));
@@ -389,7 +368,9 @@ get(const basic_value<C, M, V>& v)
        throw std::out_of_range(detail::format_underline(concat_to_string(
            "toml::get: specified std::tuple with ",
            std::tuple_size<T>::value, " elements, but there are ", ar.size(),
-            " elements in toml array."), {{v.location(), "here"}}));
+            " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
    }
    return detail::get_tuple_impl<T>(ar,
            detail::make_index_sequence<std::tuple_size<T>::value>{});
@@ -415,7 +396,7 @@ get(const basic_value<C, M, V>& v)
    T map;
    for(const auto& kv : v.as_table())
    {
-        map.emplace(key_type(kv.first), get<mapped_type>(kv.second));
+        map[key_type(kv.first)] = ::toml::get<mapped_type>(kv.second);
    }
    return map;
 }
@@ -468,7 +449,10 @@ basic_value<C, M, V> const& find(const basic_value<C, M, V>& v, const key& ky)
    const auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
-        detail::throw_key_not_found_error(v, ky);
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return tab.at(ky);
 }
@@ -479,7 +463,10 @@ basic_value<C, M, V>& find(basic_value<C, M, V>& v, const key& ky)
    auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
-        detail::throw_key_not_found_error(v, ky);
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return tab.at(ky);
 }
@@ -490,7 +477,10 @@ basic_value<C, M, V> find(basic_value<C, M, V>&& v, const key& ky)
    typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
    if(tab.count(ky) == 0)
    {
-        detail::throw_key_not_found_error(v, ky);
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return basic_value<C, M, V>(std::move(tab.at(ky)));
 }
@@ -506,7 +496,9 @@ find(const basic_value<C, M, V>& v, const std::size_t idx)
    if(ary.size() <= idx)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
    }
    return ary.at(idx);
 }
@@ -518,7 +510,9 @@ basic_value<C, M, V>& find(basic_value<C, M, V>& v, const std::size_t idx)
    if(ary.size() <= idx)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
    }
    return ary.at(idx);
 }
@@ -530,7 +524,9 @@ basic_value<C, M, V> find(basic_value<C, M, V>&& v, const std::size_t idx)
    if(ary.size() <= idx)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
    }
    return basic_value<C, M, V>(std::move(ary.at(idx)));
 }
@@ -546,7 +542,10 @@ find(const basic_value<C, M, V>& v, const key& ky)
    const auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
-        detail::throw_key_not_found_error(v, ky);
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return ::toml::get<T>(tab.at(ky));
 }
@@ -559,7 +558,10 @@ find(basic_value<C, M, V>& v, const key& ky)
    auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
-        detail::throw_key_not_found_error(v, ky);
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return ::toml::get<T>(tab.at(ky));
 }
@@ -572,7 +574,10 @@ find(basic_value<C, M, V>&& v, const key& ky)
    typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
    if(tab.count(ky) == 0)
    {
-        detail::throw_key_not_found_error(v, ky);
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
    }
    return ::toml::get<T>(std::move(tab.at(ky)));
 }
@@ -588,7 +593,9 @@ find(const basic_value<C, M, V>& v, const std::size_t idx)
    if(ary.size() <= idx)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
    }
    return ::toml::get<T>(ary.at(idx));
 }
@@ -601,7 +608,9 @@ find(basic_value<C, M, V>& v, const std::size_t idx)
    if(ary.size() <= idx)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
    }
    return ::toml::get<T>(ary.at(idx));
 }
@@ -614,7 +623,9 @@ find(basic_value<C, M, V>&& v, const std::size_t idx)
    if(ary.size() <= idx)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
    }
    return ::toml::get<T>(std::move(ary.at(idx)));
 }
--- a/toml/lexer.hpp
+++ b/toml/lexer.hpp
@@ -2,13 +2,12 @@
 // Distributed under the MIT License.
 #ifndef TOML11_LEXER_HPP
 #define TOML11_LEXER_HPP
+#include "combinator.hpp"
+#include <stdexcept>
 #include <istream>
 #include <sstream>
-#include <stdexcept>
 #include <fstream>

-#include "combinator.hpp"
-
 namespace toml
 {
 namespace detail
@@ -70,8 +69,15 @@ using lex_zero_prefixable_int = sequence<lex_digit, repeat<either<lex_digit,

 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,
@@ -119,11 +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>>>;
@@ -142,47 +154,19 @@ using lex_basic_string = sequence<lex_quotation_mark,
                                  repeat<lex_basic_char, unlimited>,
                                  lex_quotation_mark>;

-// After toml post-v0.5.0, it is explicitly clarified how quotes in ml-strings
-// are allowed to be used.
-// After this, the following strings are *explicitly* allowed.
-// - One or two `"`s in a multi-line basic string is allowed wherever it is.
-// - Three consecutive `"`s in a multi-line basic string is considered as a delimiter.
-// - One or two `"`s can appear just before or after the delimiter.
-// ```toml
-// str4 = """Here are two quotation marks: "". Simple enough."""
-// str5 = """Here are three quotation marks: ""\"."""
-// str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\"."""
-// str7 = """"This," she said, "is just a pointless statement.""""
-// ```
-// In the current implementation (v3.3.0), it is difficult to parse `str7` in
-// the above example. It is difficult to recognize `"` at the end of string body
-// collectly. It will be misunderstood as a `"""` delimiter and an additional,
-// invalid `"`. Like this:
-// ```console
-//   what():  [error] toml::parse_table: invalid line format
-//  --> hoge.toml
-//     |
-//  13 | str7 = """"This," she said, "is just a pointless statement.""""
-//     |                                                               ^- expected newline, but got '"'.
-// ```
-// As a quick workaround for this problem, `lex_ml_basic_string_delim` was
-// splitted into two, `lex_ml_basic_string_open` and `lex_ml_basic_string_close`.
-// `lex_ml_basic_string_open` allows only `"""`. `_close` allows 3-5 `"`s.
-// In parse_ml_basic_string() function, the trailing `"`s will be attached to
-// the string body.
-//
 using lex_ml_basic_string_delim = repeat<lex_quotation_mark, exactly<3>>;
-using lex_ml_basic_string_open  = lex_ml_basic_string_delim;
-using lex_ml_basic_string_close = sequence<
-        repeat<lex_quotation_mark, exactly<3>>,
-        maybe<lex_quotation_mark>, maybe<lex_quotation_mark>
-    >;
-
+#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>, // backslash
-                                                 character<0x7F>, // DEL
+                                                 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,
@@ -192,9 +176,9 @@ using lex_ml_basic_char = either<lex_ml_basic_unescaped, lex_escaped>;
 using lex_ml_basic_body = repeat<either<lex_ml_basic_char, lex_newline,
                                        lex_ml_basic_escaped_newline>,
                                 unlimited>;
-using lex_ml_basic_string = sequence<lex_ml_basic_string_open,
+using lex_ml_basic_string = sequence<lex_ml_basic_string_delim,
                                     lex_ml_basic_body,
-                                     lex_ml_basic_string_close>;
+                                     lex_ml_basic_string_delim>;

 using lex_literal_char = exclude<either<in_range<0x00, 0x08>,
                                        in_range<0x10, 0x19>, character<0x27>>>;
@@ -203,13 +187,7 @@ using lex_literal_string = sequence<lex_apostrophe,
                                    repeat<lex_literal_char, unlimited>,
                                    lex_apostrophe>;

-// the same reason as above.
 using lex_ml_literal_string_delim = repeat<lex_apostrophe, exactly<3>>;
-using lex_ml_literal_string_open  = lex_ml_literal_string_delim;
-using lex_ml_literal_string_close = sequence<
-        repeat<lex_apostrophe, exactly<3>>,
-        maybe<lex_apostrophe>, maybe<lex_apostrophe>
-    >;

 using lex_ml_literal_char = exclude<either<in_range<0x00, 0x08>,
                                           in_range<0x10, 0x1F>,
@@ -217,9 +195,9 @@ using lex_ml_literal_char = exclude<either<in_range<0x00, 0x08>,
                                           lex_ml_literal_string_delim>>;
 using lex_ml_literal_body = repeat<either<lex_ml_literal_char, lex_newline>,
                                   unlimited>;
-using lex_ml_literal_string = sequence<lex_ml_literal_string_open,
+using lex_ml_literal_string = sequence<lex_ml_literal_string_delim,
                                       lex_ml_literal_body,
-                                       lex_ml_literal_string_close>;
+                                       lex_ml_literal_string_delim>;

 using lex_string = either<lex_ml_basic_string,   lex_basic_string,
                          lex_ml_literal_string, lex_literal_string>;
--- a/toml/literal.hpp
+++ b/toml/literal.hpp
@@ -11,9 +11,12 @@ inline namespace literals
 inline namespace toml_literals
 {

-// implementation
-inline ::toml::value literal_internal_impl(::toml::detail::location loc)
+inline ::toml::value operator"" _toml(const char* str, std::size_t len)
 {
+    ::toml::detail::location<std::vector<char>>
+        loc(/* filename = */ std::string("TOML literal encoded in a C++ code"),
+            /* contents = */ std::vector<char>(str, str + len));
+
    // if there are some comments or empty lines, skip them.
    using skip_line = ::toml::detail::repeat<toml::detail::sequence<
            ::toml::detail::maybe<::toml::detail::lex_ws>,
@@ -73,34 +76,11 @@ inline ::toml::value literal_internal_impl(::toml::detail::location loc)
    }
    else // none of them.
    {
-        throw ::toml::syntax_error(data.unwrap_err(), source_location(loc));
+        throw ::toml::syntax_error(data.unwrap_err(),
+                                   source_location(std::addressof(loc)));
    }
-
 }

-inline ::toml::value operator"" _toml(const char* str, std::size_t len)
-{
-    ::toml::detail::location loc(
-            std::string("TOML literal encoded in a C++ code"),
-            std::vector<char>(str, str + len));
-    return literal_internal_impl(std::move(loc));
-}
-
-// value of __cplusplus in C++2a/20 mode is not fixed yet along compilers.
-// So here we use the feature test macro for `char8_t` itself.
-#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
-// value of u8"" literal has been changed from char to char8_t and char8_t is
-// NOT compatible to char
-inline ::toml::value operator"" _toml(const char8_t* str, std::size_t len)
-{
-    ::toml::detail::location loc(
-            std::string("TOML literal encoded in a C++ code"),
-            std::vector<char>(reinterpret_cast<const char*>(str),
-                              reinterpret_cast<const char*>(str) + len));
-    return literal_internal_impl(std::move(loc));
-}
-#endif
-
 } // toml_literals
 } // literals
 } // toml
--- a/toml/parser.hpp
+++ b/toml/parser.hpp
--- a/toml/region.hpp
+++ b/toml/region.hpp
@@ -55,7 +55,7 @@ struct region_base
    // number of characters in the line after the region
    virtual std::size_t after()    const noexcept {return 0;}

-    virtual std::vector<std::string> comments() const {return {};}
+    virtual std::vector<std::string> comments()const {return {};}
    // ```toml
    // # comment_before
    // key = "value" # comment_inline
@@ -67,21 +67,22 @@ struct region_base
 //
 // it contains pointer to the file content and iterator that points the current
 // location.
+template<typename Container>
 struct location final : public region_base
 {
-    using const_iterator  = typename std::vector<char>::const_iterator;
+    using const_iterator  = typename Container::const_iterator;
    using difference_type = typename const_iterator::difference_type;
-    using source_ptr      = std::shared_ptr<const std::vector<char>>;
+    using source_ptr      = std::shared_ptr<const Container>;

-    location(std::string name, std::vector<char> cont)
-      : source_(std::make_shared<std::vector<char>>(std::move(cont))),
-        line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin())
-    {}
-    location(std::string name, const std::string& cont)
-      : source_(std::make_shared<std::vector<char>>(cont.begin(), cont.end())),
-        line_number_(1), source_name_(std::move(name)), iter_(source_->cbegin())
-    {}
+    static_assert(std::is_same<char, typename Container::value_type>::value,"");
+    static_assert(std::is_same<std::random_access_iterator_tag,
+        typename std::iterator_traits<const_iterator>::iterator_category>::value,
+        "container should be randomly accessible");

+    location(std::string name, Container cont)
+      : source_(std::make_shared<Container>(std::move(cont))), line_number_(1),
+        source_name_(std::move(name)), iter_(source_->cbegin())
+    {}
    location(const location&) = default;
    location(location&&)      = default;
    location& operator=(const location&) = default;
@@ -194,27 +195,33 @@ struct location final : public region_base
 //
 // it contains pointer to the file content and iterator that points the first
 // and last location.
+template<typename Container>
 struct region final : public region_base
 {
-    using const_iterator = typename std::vector<char>::const_iterator;
-    using source_ptr     = std::shared_ptr<const std::vector<char>>;
+    using const_iterator = typename Container::const_iterator;
+    using source_ptr     = std::shared_ptr<const Container>;
+
+    static_assert(std::is_same<char, typename Container::value_type>::value,"");
+    static_assert(std::is_same<std::random_access_iterator_tag,
+        typename std::iterator_traits<const_iterator>::iterator_category>::value,
+        "container should be randomly accessible");

    // delete default constructor. source_ never be null.
    region() = delete;

-    explicit region(const location& loc)
+    region(const location<Container>& loc)
      : source_(loc.source()), source_name_(loc.name()),
        first_(loc.iter()), last_(loc.iter())
    {}
-    explicit region(location&& loc)
+    region(location<Container>&& loc)
      : source_(loc.source()), source_name_(loc.name()),
        first_(loc.iter()), last_(loc.iter())
    {}

-    region(const location& loc, const_iterator f, const_iterator l)
+    region(const location<Container>& loc, const_iterator f, const_iterator l)
      : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l)
    {}
-    region(location&& loc, const_iterator f, const_iterator l)
+    region(location<Container>&& loc, const_iterator f, const_iterator l)
      : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l)
    {}

@@ -412,6 +419,107 @@ struct region final : public region_base
    const_iterator first_, last_;
 };

+// 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 bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
+{
+    assert(!reg_com.empty());
+
+    const auto line_num_width = static_cast<int>(std::max_element(
+        reg_com.begin(), reg_com.end(),
+        [](std::pair<region_base const*, std::string> const& lhs,
+           std::pair<region_base const*, std::string> const& rhs)
+        {
+            return lhs.first->line_num().size() < rhs.first->line_num().size();
+        }
+    )->first->line_num().size());
+
+    std::ostringstream retval;
+
+    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)
+    {
+        // if the filenames are the same, print "..."
+        if(iter != reg_com.begin() &&
+           std::prev(iter)->first->name() == iter->first->name())
+        {
+            retval << color::bold << color::blue << "\n ...\n" << color::reset;
+        }
+        else // if filename differs, print " --> filename.toml"
+        {
+            if(iter != reg_com.begin()) {retval << '\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 << ' ' << color::bold << color::blue << std::setw(line_num_width)
+               << std::right << 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 << color::bold << color::red
+                   << '^' << make_string(reg->after(), '-') << color::reset;
+        }
+        else
+        {
+            // invalid
+            // ~~~~~~~
+            const auto underline_len = std::min(reg->size(), reg->line().size());
+            retval << color::bold << color::red
+                   << make_string(underline_len, '~') << color::reset;
+        }
+        retval << ' ';
+        retval << comment;
+    }
+
+    if(!helps.empty())
+    {
+        retval << '\n';
+        retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ');
+        retval << color::bold << color::blue << " | " << color::reset;
+        for(const auto help : helps)
+        {
+            retval << color::bold << "\nHint: " << color::reset;
+            retval << help;
+        }
+    }
+    return retval.str();
+}
+
 } // detail
 } // toml
 #endif// TOML11_REGION_H
--- a/toml/serializer.hpp
+++ b/toml/serializer.hpp
@@ -2,12 +2,11 @@
 // Distributed under the MIT License.
 #ifndef TOML11_SERIALIZER_HPP
 #define TOML11_SERIALIZER_HPP
-#include <cstdio>
-
-#include <limits>
-
-#include "lexer.hpp"
 #include "value.hpp"
+#include "lexer.hpp"
+#include "visit.hpp"
+#include <limits>
+#include <cstdio>

 namespace toml
 {
@@ -24,62 +23,39 @@ namespace toml
 // Since toml restricts characters available in a bare key, generally a string
 // should be escaped. But checking whether a string needs to be surrounded by
 // a `"` and escaping some special character is boring.
-template<typename charT, typename traits, typename Alloc>
-std::basic_string<charT, traits, Alloc>
-format_key(const std::basic_string<charT, traits, Alloc>& key)
+inline std::string format_key(const toml::key& key)
 {
-    // check the key can be a bare (unquoted) key
-    detail::location loc(key, std::vector<char>(key.begin(), key.end()));
+    detail::location<toml::key> loc(key, key);
    detail::lex_unquoted_key::invoke(loc);
    if(loc.iter() == loc.end())
    {
        return key; // all the tokens are consumed. the key is unquoted-key.
    }
-
-    //if it includes special characters, then format it in a "quoted" key.
-    std::basic_string<charT, traits, Alloc> serialized("\"");
+    std::string token("\"");
    for(const char c : key)
    {
        switch(c)
        {
-            case '\\': {serialized += "\\\\"; break;}
-            case '\"': {serialized += "\\\""; break;}
-            case '\b': {serialized += "\\b";  break;}
-            case '\t': {serialized += "\\t";  break;}
-            case '\f': {serialized += "\\f";  break;}
-            case '\n': {serialized += "\\n";  break;}
-            case '\r': {serialized += "\\r";  break;}
-            default  : {serialized += c;      break;}
+            case '\\': {token += "\\\\"; break;}
+            case '\"': {token += "\\\""; break;}
+            case '\b': {token += "\\b";  break;}
+            case '\t': {token += "\\t";  break;}
+            case '\f': {token += "\\f";  break;}
+            case '\n': {token += "\\n";  break;}
+            case '\r': {token += "\\r";  break;}
+            default  : {token += c;      break;}
        }
    }
-    serialized += "\"";
-    return serialized;
+    token += "\"";
+    return token;
 }

-template<typename charT, typename traits, typename Alloc>
-std::basic_string<charT, traits, Alloc>
-format_keys(const std::vector<std::basic_string<charT, traits, Alloc>>& keys)
-{
-    std::basic_string<charT, traits, Alloc> serialized;
-    if(keys.empty()) {return serialized;}
-
-    for(const auto& ky : keys)
-    {
-        serialized += format_key(ky);
-        serialized += charT('.');
-    }
-    serialized.pop_back(); // remove the last dot '.'
-    return serialized;
-}
-
-template<typename Value>
+template<typename Comment,
+         template<typename ...> class Table,
+         template<typename ...> class Array>
 struct serializer
 {
-    static_assert(detail::is_basic_value<Value>::value,
-                  "toml::serializer is for toml::value and its variants, "
-                  "toml::basic_value<...>.");
-
-    using value_type           = Value;
+    using value_type           = basic_value<Comment, Table, Array>;
    using key_type             = typename value_type::key_type            ;
    using comment_type         = typename value_type::comment_type        ;
    using boolean_type         = typename value_type::boolean_type        ;
@@ -137,6 +113,35 @@ struct serializer
        {
            // the resulting value does not have any float specific part!
            token += ".0";
+            return token;
+        }
+        if(!has_exponent)
+        {
+            return token; // there is no exponent part. just return it.
+        }
+#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;
+        for(auto iter = std::next(e), iend = token.cend(); iter != iend; ++iter)
+        {
+            if(*iter == '+' || *iter == '-'){sign_exists = true; continue;}
+            if(*iter == '0'){zero_prefix += 1;}
+            else {break;}
+        }
+        if(zero_prefix != 0)
+        {
+            const auto offset = std::distance(token.cbegin(), e) +
+                               (sign_exists ? 2 : 1);
+            token.erase(static_cast<typename std::string::size_type>(offset),
+                        zero_prefix);
        }
        return token;
    }
@@ -144,23 +149,12 @@ struct serializer
    {
        if(s.kind == string_t::basic)
        {
-            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() ||
-               std::find(s.str.cbegin(), s.str.cend(), '\"') != s.str.cend())
+            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend())
            {
-                // if linefeed or double-quote is contained,
-                // make it multiline basic string.
-                const auto escaped = this->escape_ml_basic_string(s.str);
-                std::string open("\"\"\"");
-                std::string close("\"\"\"");
-                if(escaped.find('\n') != std::string::npos ||
-                   this->width_ < escaped.size() + 6)
-                {
-                    // if the string body contains newline or is enough long,
-                    // add newlines after and before delimiters.
-                    open += "\n";
-                    close = std::string("\\\n") + close;
-                }
-                return open + escaped + close;
+                // if linefeed is contained, make it multiline-string.
+                const std::string open("\"\"\"\n");
+                const std::string close("\\\n\"\"\"");
+                return open + this->escape_ml_basic_string(s.str) + close;
            }

            // no linefeed. try to make it oneline-string.
@@ -201,11 +195,7 @@ struct serializer
            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() ||
               std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() )
            {
-                std::string open("'''");
-                if(this->width_ + 6 < s.str.size())
-                {
-                    open += '\n'; // the first newline is ignored by TOML spec
-                }
+                const std::string open("'''\n");
                const std::string close("'''");
                return open + s.str + close;
            }
@@ -260,7 +250,7 @@ struct serializer
                std::string token;
                if(!keys_.empty())
                {
-                    token += format_key(keys_.back());
+                    token += this->serialize_key(keys_.back());
                    token += " = ";
                }
                bool failed = false;
@@ -316,7 +306,7 @@ struct serializer
                    }
                }
                token += "[[";
-                token += format_keys(keys_);
+                token += this->serialize_dotted_key(keys_);
                token += "]]\n";
                token += this->make_multiline_table(item.as_table());
            }
@@ -428,7 +418,7 @@ struct serializer
            std::string token;
            if(!this->keys_.empty())
            {
-                token += format_key(this->keys_.back());
+                token += this->serialize_key(this->keys_.back());
                token += " = ";
            }
            token += this->make_inline_table(v);
@@ -443,7 +433,7 @@ struct serializer
        if(!keys_.empty())
        {
            token += '[';
-            token += format_keys(keys_);
+            token += this->serialize_dotted_key(keys_);
            token += "]\n";
        }
        token += this->make_multiline_table(v);
@@ -452,6 +442,25 @@ struct serializer

  private:

+    std::string serialize_key(const toml::key& key) const
+    {
+        return ::toml::format_key(key);
+    }
+
+    std::string serialize_dotted_key(const std::vector<toml::key>& keys) const
+    {
+        std::string token;
+        if(keys.empty()){return token;}
+
+        for(const auto& k : keys)
+        {
+            token += this->serialize_key(k);
+            token += '.';
+        }
+        token.erase(token.size() - 1, 1); // remove trailing `.`
+        return token;
+    }
+
    std::string escape_basic_string(const std::string& s) const
    {
        //XXX assuming `s` is a valid utf-8 sequence.
@@ -481,9 +490,7 @@ struct serializer
            switch(*i)
            {
                case '\\': {retval += "\\\\"; break;}
-                // One or two consecutive "s are allowed.
-                // Later we will check there are no three consecutive "s.
-                //   case '\"': {retval += "\\\""; break;}
+                case '\"': {retval += "\\\""; break;}
                case '\b': {retval += "\\b";  break;}
                case '\t': {retval += "\\t";  break;}
                case '\f': {retval += "\\f";  break;}
@@ -504,23 +511,6 @@ struct serializer
                default: {retval += *i; break;}
            }
        }
-        // Only 1 or 2 consecutive `"`s are allowed in multiline basic string.
-        // 3 consecutive `"`s are considered as a closing delimiter.
-        // We need to check if there are 3 or more consecutive `"`s and insert
-        // backslash to break them down into several short `"`s like the `str6`
-        // in the following example.
-        // ```toml
-        // str4 = """Here are two quotation marks: "". Simple enough."""
-        // # str5 = """Here are three quotation marks: """."""  # INVALID
-        // str5 = """Here are three quotation marks: ""\"."""
-        // str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\"."""
-        // ```
-        auto found_3_quotes = retval.find("\"\"\"");
-        while(found_3_quotes != std::string::npos)
-        {
-            retval.replace(found_3_quotes, 3, "\"\"\\\"");
-            found_3_quotes = retval.find("\"\"\"");
-        }
        return retval;
    }

@@ -557,7 +547,7 @@ struct serializer
        for(const auto& item : v)
        {
            if(is_first) {is_first = false;} else {token += ',';}
-            token += visit(serializer((std::numeric_limits<std::size_t>::max)(),
+            token += visit(serializer(std::numeric_limits<std::size_t>::max(),
                                      this->float_prec_, true), item);
        }
        token += ']';
@@ -575,9 +565,9 @@ struct serializer
        {
            // in inline tables, trailing comma is not allowed (toml-lang #569).
            if(is_first) {is_first = false;} else {token += ',';}
-            token += format_key(kv.first);
+            token += this->serialize_key(kv.first);
            token += '=';
-            token += visit(serializer((std::numeric_limits<std::size_t>::max)(),
+            token += visit(serializer(std::numeric_limits<std::size_t>::max(),
                                      this->float_prec_, true), kv.second);
        }
        token += '}';
@@ -590,7 +580,7 @@ struct serializer

        // print non-table stuff first. because after printing [foo.bar], the
        // remaining non-table values will be assigned into [foo.bar], not [foo]
-        for(const auto& kv : v)
+        for(const auto kv : v)
        {
            if(kv.second.is_table() || is_array_of_tables(kv.second))
            {
@@ -606,7 +596,7 @@ struct serializer
                    token += '\n';
                }
            }
-            const auto key_and_sep    = format_key(kv.first) + " = ";
+            const auto key_and_sep    = this->serialize_key(kv.first) + " = ";
            const auto residual_width = (this->width_ > key_and_sep.size()) ?
                                        this->width_ - key_and_sep.size() : 0;
            token += key_and_sep;
@@ -688,7 +678,6 @@ format(const basic_value<C, M, V>& v, std::size_t w = 80u,
       int fprec = std::numeric_limits<toml::floating>::max_digits10,
       bool no_comment = false, bool force_inline = false)
 {
-    using value_type = basic_value<C, M, V>;
    // if value is a table, it is considered to be a root object.
    // the root object can't be an inline table.
    if(v.is_table())
@@ -699,11 +688,10 @@ format(const basic_value<C, M, V>& v, std::size_t w = 80u,
            oss << v.comments();
            oss << '\n'; // to split the file comment from the first element
        }
-        const auto serialized = visit(serializer<value_type>(w, fprec, no_comment, false), v);
-        oss << serialized;
+        oss << visit(serializer<C, M, V>(w, fprec, no_comment, false), v);
        return oss.str();
    }
-    return visit(serializer<value_type>(w, fprec, force_inline), v);
+    return visit(serializer<C, M, V>(w, fprec, force_inline), v);
 }

 namespace detail
@@ -739,8 +727,6 @@ template<typename charT, typename traits, typename C,
 std::basic_ostream<charT, traits>&
 operator<<(std::basic_ostream<charT, traits>& os, const basic_value<C, M, V>& v)
 {
-    using value_type = basic_value<C, M, V>;
-
    // get status of std::setw().
    const auto w     = static_cast<std::size_t>(os.width());
    const int  fprec = static_cast<int>(os.precision());
@@ -756,8 +742,7 @@ operator<<(std::basic_ostream<charT, traits>& os, const basic_value<C, M, V>& v)
        os << '\n'; // to split the file comment from the first element
    }
    // the root object can't be an inline table. so pass `false`.
-    const auto serialized = visit(serializer<value_type>(w, fprec, no_comment, false), v);
-    os << serialized;
+    os << visit(serializer<C, M, V>(w, fprec, false, no_comment), v);

    // if v is a non-table value, and has only one comment, then
    // put a comment just after a value. in the following way.
--- a/toml/source_location.hpp
+++ b/toml/source_location.hpp
@@ -2,9 +2,8 @@
 // Distributed under the MIT License.
 #ifndef TOML11_SOURCE_LOCATION_HPP
 #define TOML11_SOURCE_LOCATION_HPP
-#include <cstdint>
-
 #include "region.hpp"
+#include <cstdint>

 namespace toml
 {
@@ -39,12 +38,12 @@ struct source_location
  public:

    source_location()
-        : line_num_(1), column_num_(1), region_size_(1),
+        : line_num_(0), column_num_(0), region_size_(0),
          file_name_("unknown file"), line_str_("")
    {}

    explicit source_location(const detail::region_base* reg)
-        : line_num_(1), column_num_(1), region_size_(1),
+        : line_num_(0), column_num_(0), region_size_(0),
          file_name_("unknown file"), line_str_("")
    {
        if(reg)
@@ -61,21 +60,6 @@ struct source_location
        }
    }

-    explicit source_location(const detail::region& reg)
-        : 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()),
-          line_str_ (reg.line())
-    {}
-    explicit source_location(const detail::location& loc)
-        : line_num_(static_cast<std::uint_least32_t>(std::stoul(loc.line_num()))),
-          column_num_(static_cast<std::uint_least32_t>(loc.before() + 1)),
-          region_size_(static_cast<std::uint_least32_t>(loc.size())),
-          file_name_(loc.name()),
-          line_str_ (loc.line())
-    {}
-
    ~source_location() = default;
    source_location(source_location const&) = default;
    source_location(source_location &&)     = default;
@@ -98,135 +82,5 @@ struct source_location
    std::string         line_str_;
 };

-namespace detail
-{
-
-// internal error message generation.
-inline std::string format_underline(const std::string& message,
-        const std::vector<std::pair<source_location, std::string>>& loc_com,
-        const std::vector<std::string>& helps = {},
-        const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
-{
-    std::size_t line_num_width = 0;
-    for(const auto& lc : loc_com)
-    {
-        std::uint_least32_t line = lc.first.line();
-        std::size_t        digit = 0;
-        while(line != 0)
-        {
-            line  /= 10;
-            digit +=  1;
-        }
-        line_num_width = (std::max)(line_num_width, digit);
-    }
-    // 1 is the minimum width
-    line_num_width = std::max<std::size_t>(line_num_width, 1);
-
-    std::ostringstream retval;
-
-    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';
-    }
-
-    const auto format_one_location = [line_num_width]
-        (std::ostringstream& oss,
-         const source_location& loc, const std::string& comment) -> void
-        {
-            oss << ' ' << color::bold << color::blue
-                << std::setw(static_cast<int>(line_num_width))
-                << std::right << loc.line() << " | "  << color::reset
-                << loc.line_str() << '\n';
-
-            oss << make_string(line_num_width + 1, ' ')
-                << color::bold << color::blue << " | " << color::reset
-                << make_string(loc.column()-1 /*1-origin*/, ' ');
-
-            if(loc.region() == 1)
-            {
-                // invalid
-                // ^------
-                oss << color::bold << color::red << "^---" << color::reset;
-            }
-            else
-            {
-                // invalid
-                // ~~~~~~~
-                const auto underline_len = (std::min)(
-                    static_cast<std::size_t>(loc.region()), loc.line_str().size());
-                oss << color::bold << color::red
-                    << make_string(underline_len, '~') << color::reset;
-            }
-            oss << ' ';
-            oss << comment;
-            return;
-        };
-
-    assert(!loc_com.empty());
-
-    // --> example.toml
-    //   |
-    retval << color::bold << color::blue << " --> " << color::reset
-           << loc_com.front().first.file_name() << '\n';
-    retval << make_string(line_num_width + 1, ' ')
-           << color::bold << color::blue << " |\n"  << color::reset;
-    // 1 | key value
-    //   |    ^--- missing =
-    format_one_location(retval, loc_com.front().first, loc_com.front().second);
-
-    // process the rest of the locations
-    for(std::size_t i=1; i<loc_com.size(); ++i)
-    {
-        const auto& prev = loc_com.at(i-1);
-        const auto& curr = loc_com.at(i);
-
-        retval << '\n';
-        // if the filenames are the same, print "..."
-        if(prev.first.file_name() == curr.first.file_name())
-        {
-            retval << color::bold << color::blue << " ...\n" << color::reset;
-        }
-        else // if filename differs, print " --> filename.toml" again
-        {
-            retval << color::bold << color::blue << " --> " << color::reset
-                   << curr.first.file_name() << '\n';
-            retval << make_string(line_num_width + 1, ' ')
-                   << color::bold << color::blue << " |\n"  << color::reset;
-        }
-
-        format_one_location(retval, curr.first, curr.second);
-    }
-
-    if(!helps.empty())
-    {
-        retval << '\n';
-        retval << make_string(line_num_width + 1, ' ');
-        retval << color::bold << color::blue << " |" << color::reset;
-        for(const auto& help : helps)
-        {
-            retval << color::bold << "\nHint: " << color::reset;
-            retval << help;
-        }
-    }
-    return retval.str();
-}
-
-} // detail
 } // toml
 #endif// TOML11_SOURCE_LOCATION_HPP
--- a/toml/string.hpp
+++ b/toml/string.hpp
@@ -2,11 +2,9 @@
 // Distributed under the MIT License.
 #ifndef TOML11_STRING_HPP
 #define TOML11_STRING_HPP
-#include <cstdint>
-
 #include <algorithm>
 #include <string>
-
+#include <cstdint>
 #if __cplusplus >= 201703L
 #if __has_include(<string_view>)
 #include <string_view>
--- a/toml/traits.hpp
+++ b/toml/traits.hpp
@@ -2,13 +2,11 @@
 // Distributed under the MIT License.
 #ifndef TOML11_TRAITS_HPP
 #define TOML11_TRAITS_HPP
-#include <chrono>
-#include <forward_list>
-#include <string>
-#include <tuple>
 #include <type_traits>
 #include <utility>
-
+#include <chrono>
+#include <tuple>
+#include <string>
 #if __cplusplus >= 201703L
 #if __has_include(<string_view>)
 #include <string_view>
@@ -45,23 +43,17 @@ struct has_mapped_type_impl
    template<typename T> static std::true_type  check(typename T::mapped_type*);
    template<typename T> static std::false_type check(...);
 };
-struct has_reserve_method_impl
+struct has_resize_method_impl
 {
+    constexpr static std::size_t dummy=0;
+    template<typename T> static std::true_type  check(decltype(std::declval<T>().resize(dummy))*);
    template<typename T> static std::false_type check(...);
-    template<typename T> static std::true_type  check(
-        decltype(std::declval<T>().reserve(std::declval<std::size_t>()))*);
-};
-struct has_push_back_method_impl
-{
-    template<typename T> static std::false_type check(...);
-    template<typename T> static std::true_type  check(
-        decltype(std::declval<T>().push_back(std::declval<typename T::value_type>()))*);
 };
+
 struct is_comparable_impl
 {
+    template<typename T> static std::true_type  check(decltype(std::declval<T>() < std::declval<T>())*);
    template<typename T> static std::false_type check(...);
-    template<typename T> static std::true_type  check(
-        decltype(std::declval<T>() < std::declval<T>())*);
 };

 struct has_from_toml_method_impl
@@ -99,9 +91,7 @@ struct has_key_type    : decltype(has_key_type_impl::check<T>(nullptr)){};
 template<typename T>
 struct has_mapped_type : decltype(has_mapped_type_impl::check<T>(nullptr)){};
 template<typename T>
-struct has_reserve_method : decltype(has_reserve_method_impl::check<T>(nullptr)){};
-template<typename T>
-struct has_push_back_method : decltype(has_push_back_method_impl::check<T>(nullptr)){};
+struct has_resize_method : decltype(has_resize_method_impl::check<T>(nullptr)){};
 template<typename T>
 struct is_comparable : decltype(is_comparable_impl::check<T>(nullptr)){};

@@ -159,10 +149,6 @@ template<typename T> struct is_std_tuple : std::false_type{};
 template<typename ... Ts>
 struct is_std_tuple<std::tuple<Ts...>> : std::true_type{};

-template<typename T> struct is_std_forward_list : std::false_type{};
-template<typename T>
-struct is_std_forward_list<std::forward_list<T>> : std::true_type{};
-
 template<typename T> struct is_chrono_duration: std::false_type{};
 template<typename Rep, typename Period>
 struct is_chrono_duration<std::chrono::duration<Rep, Period>>: std::true_type{};
--- a/toml/types.hpp
+++ b/toml/types.hpp
@@ -2,13 +2,12 @@
 // Distributed under the MIT License.
 #ifndef TOML11_TYPES_HPP
 #define TOML11_TYPES_HPP
-#include <unordered_map>
-#include <vector>
-
-#include "comments.hpp"
 #include "datetime.hpp"
 #include "string.hpp"
 #include "traits.hpp"
+#include "comments.hpp"
+#include <vector>
+#include <unordered_map>

 namespace toml
 {
--- a/toml/utility.hpp
+++ b/toml/utility.hpp
@@ -2,11 +2,10 @@
 // Distributed under the MIT License.
 #ifndef TOML11_UTILITY_HPP
 #define TOML11_UTILITY_HPP
+#include "traits.hpp"
+#include <utility>
 #include <memory>
 #include <sstream>
-#include <utility>
-
-#include "traits.hpp"

 #if __cplusplus >= 201402L
 #  define TOML11_MARK_AS_DEPRECATED(msg) [[deprecated(msg)]]
@@ -37,25 +36,30 @@ inline std::unique_ptr<T> make_unique(Ts&& ... args)

 namespace detail
 {
-template<typename Container>
-void try_reserve_impl(Container& container, std::size_t N, std::true_type)
+
+template<typename T>
+inline void resize_impl(T& container, std::size_t N, std::true_type)
 {
-    container.reserve(N);
-    return;
+    container.resize(N);
+    return ;
 }
-template<typename Container>
-void try_reserve_impl(Container&, std::size_t, std::false_type) noexcept
+
+template<typename T>
+inline void resize_impl(T& container, std::size_t N, std::false_type)
 {
-    return;
+    if(container.size() >= N) {return;}
+
+    throw std::invalid_argument("not resizable type");
 }
+
 } // detail

-template<typename Container>
-void try_reserve(Container& container, std::size_t N)
+template<typename T>
+inline void resize(T& container, std::size_t N)
 {
-    if(N <= container.size()) {return;}
-    detail::try_reserve_impl(container, N, detail::has_reserve_method<Container>{});
-    return;
+    if(container.size() == N) {return;}
+
+    return detail::resize_impl(container, N, detail::has_resize_method<T>());
 }

 namespace detail
--- a/toml/value.hpp
+++ b/toml/value.hpp
--- a/toml/visit.hpp
+++ b/toml/visit.hpp
@@ -0,0 +1,134 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_VISIT_HPP
+#define TOML11_VISIT_HPP
+#include "value.hpp"
+
+namespace toml
+{
+template<typename Visitor, typename C,
+         template<typename ...> class T, template<typename ...> class A>
+detail::return_type_of_t<Visitor, const toml::boolean&>
+visit(Visitor&& visitor, const toml::basic_value<C, T, A>& v)
+{
+    switch(v.type())
+    {
+        case value_t::boolean        : {return visitor(v.as_boolean        ());}
+        case value_t::integer        : {return visitor(v.as_integer        ());}
+        case value_t::floating       : {return visitor(v.as_floating       ());}
+        case value_t::string         : {return visitor(v.as_string         ());}
+        case value_t::offset_datetime: {return visitor(v.as_offset_datetime());}
+        case value_t::local_datetime : {return visitor(v.as_local_datetime ());}
+        case value_t::local_date     : {return visitor(v.as_local_date     ());}
+        case value_t::local_time     : {return visitor(v.as_local_time     ());}
+        case value_t::array          : {return visitor(v.as_array          ());}
+        case value_t::table          : {return visitor(v.as_table          ());}
+        case value_t::empty          : break;
+        default: break;
+    }
+    throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value "
+            "does not have any valid basic_value.", v, "here"));
+}
+
+template<typename Visitor, typename C,
+         template<typename ...> class T, template<typename ...> class A>
+detail::return_type_of_t<Visitor, toml::boolean&>
+visit(Visitor&& visitor, toml::basic_value<C, T, A>& v)
+{
+    switch(v.type())
+    {
+        case value_t::boolean        : {return visitor(v.as_boolean        ());}
+        case value_t::integer        : {return visitor(v.as_integer        ());}
+        case value_t::floating       : {return visitor(v.as_floating       ());}
+        case value_t::string         : {return visitor(v.as_string         ());}
+        case value_t::offset_datetime: {return visitor(v.as_offset_datetime());}
+        case value_t::local_datetime : {return visitor(v.as_local_datetime ());}
+        case value_t::local_date     : {return visitor(v.as_local_date     ());}
+        case value_t::local_time     : {return visitor(v.as_local_time     ());}
+        case value_t::array          : {return visitor(v.as_array          ());}
+        case value_t::table          : {return visitor(v.as_table          ());}
+        case value_t::empty          : break;
+        default: break;
+    }
+    throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value "
+            "does not have any valid basic_value.", v, "here"));
+}
+
+template<typename Visitor, typename C,
+         template<typename ...> class T, template<typename ...> class A>
+detail::return_type_of_t<Visitor, toml::boolean&&>
+visit(Visitor&& visitor, toml::basic_value<C, T, A>&& v)
+{
+    switch(v.type())
+    {
+        case value_t::boolean        : {return visitor(std::move(v.as_boolean        ()));}
+        case value_t::integer        : {return visitor(std::move(v.as_integer        ()));}
+        case value_t::floating       : {return visitor(std::move(v.as_floating       ()));}
+        case value_t::string         : {return visitor(std::move(v.as_string         ()));}
+        case value_t::offset_datetime: {return visitor(std::move(v.as_offset_datetime()));}
+        case value_t::local_datetime : {return visitor(std::move(v.as_local_datetime ()));}
+        case value_t::local_date     : {return visitor(std::move(v.as_local_date     ()));}
+        case value_t::local_time     : {return visitor(std::move(v.as_local_time     ()));}
+        case value_t::array          : {return visitor(std::move(v.as_array          ()));}
+        case value_t::table          : {return visitor(std::move(v.as_table          ()));}
+        case value_t::empty          : break;
+        default: break;
+    }
+    throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value "
+            "does not have any valid basic_value.", v, "here"));
+}
+
+
+namespace detail
+{
+template<typename Result, typename Visitor, typename Value>
+struct visitor
+{
+    template<typename ... Ts>
+    Result operator()(Ts&& ... args)
+    {
+        return vis(value, args ...);
+    }
+    Visitor vis;
+    Value value;
+};
+
+template<typename Result, typename Visitor, typename Value>
+visitor<Result, Visitor, Value> make_visitor(Visitor&& vis, Value&& val)
+{
+    return visitor<Result, Visitor, Value>{
+        std::forward<Visitor>(vis), std::forward<Value>(val)
+    };
+}
+} // detail
+
+template<typename Visitor, typename Value, typename ... Values>
+auto visit(Visitor&& visitor, Value&& v, Values&& ... vs)
+    -> detail::enable_if_t<detail::conjunction<
+            detail::is_basic_value<Value>, detail::is_basic_value<Values> ...
+        >::value, decltype(visitor(std::forward<Value >(v ).as_boolean(),
+                                   std::forward<Values>(vs).as_boolean()...))>
+{
+    using result_t = decltype(visitor(v.as_boolean(), vs.as_boolean()...));
+    using detail::make_visitor;
+    switch(v.type())
+    {
+        case value_t::boolean        : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_boolean        ()), std::forward<Values>(vs)...);}
+        case value_t::integer        : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_integer        ()), std::forward<Values>(vs)...);}
+        case value_t::floating       : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_floating       ()), std::forward<Values>(vs)...);}
+        case value_t::string         : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_string         ()), std::forward<Values>(vs)...);}
+        case value_t::offset_datetime: {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_offset_datetime()), std::forward<Values>(vs)...);}
+        case value_t::local_datetime : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_local_datetime ()), std::forward<Values>(vs)...);}
+        case value_t::local_date     : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_local_date     ()), std::forward<Values>(vs)...);}
+        case value_t::local_time     : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_local_time     ()), std::forward<Values>(vs)...);}
+        case value_t::array          : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_array          ()), std::forward<Values>(vs)...);}
+        case value_t::table          : {return visit(make_visitor<result_t>(std::forward<Visitor>(visitor), v.as_table          ()), std::forward<Values>(vs)...);}
+        case value_t::empty          : break;
+        default: break;
+    }
+    throw std::runtime_error(format_error("[error] toml::visit: toml::basic_value "
+            "does not have any valid basic_value.", v, "here"));
+}
+
+} // toml
+#endif// TOML11_VISIT_HPP
Author	SHA1	Message	Date
ToruNiina	bfe5e50acf	test: add missing include files	2020-02-07 21:00:11 +09:00
ToruNiina	05077dee0c	test: add test_visit	2020-02-07 15:58:15 +09:00
ToruNiina	b9f1726e26	feat: add multi-argument toml::visit(visitor, ...)	2020-02-07 15:57:34 +09:00
ToruNiina	c583e38ebf	fix: include visit.hpp from serializer	2020-02-07 15:57:09 +09:00
ToruNiina	388e9db32b	refactor: move visit() from value.hpp to visit.hpp	2020-01-31 22:48:37 +09:00