chore: update version number

like:
```
a.b.c = "foo"
[a.b] # this is invalid
d = "bar"
```

.circleci/config.yml

@@ -2,19 +2,24 @@ version: 2.1
 
 jobs:
   test_suite:
-    environment:
-      - GOPATH: /home/circleci/go
     docker:
-      - image: circleci/golang:1.9
+      - image: cimg/go:1.16
     steps:
       - checkout
       - run:
           command: |
               g++ --version
               cd tests/
-              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
+              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check_toml_test.cpp -o check_toml_test
+              export PATH=$(pwd):${PATH}
+              git clone https://github.com/BurntSushi/toml-test.git
+              cd toml-test/
+              go install -v ./cmd/toml-test
+              cd -
+              toml-test check_toml_test
+#               go clean -modcache
+#               go get github.com/BurntSushi/toml-test/cmd/toml-test
+#               $GOPATH/bin/toml-test ./check_toml_test
   test_serialization:
     docker:
       - image: circleci/buildpack-deps:bionic
@@ -24,7 +29,7 @@ jobs:
           command: |
               g++ --version
               cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -I../ check_serialization.cpp -o check_serialization
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -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 +52,7 @@ jobs:
           command: |
               g++ --version
               cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -I../ check.cpp -o check
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -I../ check.cpp -o check
               git clone https://github.com/BurntSushi/toml-test.git
               cp check toml-test/tests/invalid
               cp check toml-test/tests/valid

.github/workflows/main.yml

@@ -0,0 +1,149 @@
+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++-11', 'g++-10', '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
+            sudo apt-add-repository ppa:ubuntu-toolchain-r/test
+            sudo apt-get update
+            sudo apt-get install ${{ matrix.compiler }}
+      - 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'}
+            - {compiler: '6.0', standard: '20'}
+            - {compiler: '7',   standard: '20'}
+            - {compiler: '8',   standard: '20'}
+            - {compiler: '9',   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
+            sudo apt-add-repository ppa:ubuntu-toolchain-r/test
+            sudo apt-get update
+            sudo apt-get install clang-${{ matrix.compiler }}
+      - name: Configure
+        run: |
+            mkdir build && cd build
+            cmake .. -Dtoml11_BUILD_TEST=ON -DCMAKE_C_COMPILER=clang-${{ matrix.compiler }} -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-osx:
+    runs-on: macos-10.15
+    strategy:
+      matrix:
+        standard: ['11', '14', '17', '20']
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: true
+      - name: Install
+        run: |
+            brew install boost
+      - name: Configure
+        run: |
+            mkdir build && cd build
+            cmake .. -Dtoml11_BUILD_TEST=ON -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
+      - name: Install
+        run: |
+            (New-Object System.Net.WebClient).DownloadFile("https://github.com/actions/boost-versions/releases/download/1.72.0-20200608.4/boost-1.72.0-win32-msvc14.2-x86_64.tar.gz", "$env:TEMP\\boost.tar.gz")
+            7z.exe x "$env:TEMP\\boost.tar.gz" -o"$env:TEMP\\boostArchive" -y | Out-Null
+            7z.exe x "$env:TEMP\\boostArchive" -o"$env:TEMP\\boost" -y | Out-Null
+            Push-Location -Path "$env:TEMP\\boost"
+            Invoke-Expression .\\setup.ps1
+      - 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_NO_BOOST_CMAKE=ON -DBOOST_ROOT="C:\\hostedtoolcache\\windows\\Boost\\1.72.0\\x86_64"
+      - 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

.travis.yml

@@ -2,6 +2,30 @@ 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
@@ -77,7 +101,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=17
+    env: COMPILER="g++-8" CXX_STANDARD=17 REQUIRE_FILESYSTEM_LIBRARY=ON
     addons:
       apt:
         sources:
@@ -89,7 +113,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=ON
+    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=ON REQUIRE_FILESYSTEM_LIBRARY=ON
     addons:
       apt:
         sources:
@@ -213,7 +237,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=17
+    env: COMPILER="clang++-8" CXX_STANDARD=17 REQUIRE_FILESYSTEM_LIBRARY=ON
     addons:
       apt:
         sources:
@@ -227,7 +251,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=ON
+    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=ON REQUIRE_FILESYSTEM_LIBRARY=ON
     addons:
       apt:
         sources:
@@ -269,16 +293,6 @@ 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:
 - |
@@ -288,6 +302,10 @@ 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"
@@ -303,17 +321,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
-- 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} ..
+- 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} ..
 - make
 - ctest --output-on-failure
-
-# https://stackoverflow.com/a/53331571
-before_cache:
-- |
-  if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-    brew cleanup
-  fi

CMakeLists.txt

@@ -1,26 +1,20 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.1)
 enable_testing()
 
-project(toml11)
+project(toml11 VERSION 3.7.1)
 
-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_BUILD_TEST "Build toml tests" OFF)
+option(toml11_INSTALL "Install CMake targets during install step." 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_EXTENSIONS OFF)
+    set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Boolean specifying whether compiler specific extensions are requested.")
     if(NOT DEFINED CMAKE_CXX_STANDARD)
-        set(CMAKE_CXX_STANDARD 11)
+        set(CMAKE_CXX_STANDARD 11 CACHE STRING "The C++ standard whose features are requested to build all targets.")
     endif()
-    set(CXX_STANDARD_REQUIRED ON)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "Boolean describing whether the value of CXX_STANDARD is a requirement.")
 else()
     # Manually check for C++11 compiler flag.
     CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
@@ -46,6 +40,19 @@ else()
     endif()
 endif()
 
+if(MSVC)
+#     add_definitions("/Zc:__cplusplus")  # define __cplusplus value correctly
+    add_definitions("/utf-8")           # enable to use u8"" literal
+    if(MSVC_VERSION LESS 1910)
+        message(STATUS "MSVC < 1910. DEFINE_CONVERSION_NON_INTRUSIVE is disabled")
+        add_definitions(-DTOML11_WITHOUT_DEFINE_NON_INTRUSIVE)
+    elseif(MSVC_VERSION LESS 1920)
+        add_definitions("/experimental:preprocessor") # MSVC 2017
+    else()
+        add_definitions("/Zc:preprocessor") # MSVC 2019
+    endif()
+endif()
+
 # Set some common directories
 include(GNUInstallDirs)
 set(toml11_install_cmake_dir         ${CMAKE_INSTALL_LIBDIR}/cmake/toml11)
@@ -69,38 +76,40 @@ write_basic_package_version_file(
     COMPATIBILITY SameMajorVersion
 )
 
-configure_package_config_file(
-    cmake/toml11Config.cmake.in
-    ${toml11_config}
-    INSTALL_DESTINATION ${toml11_install_cmake_dir}
-    PATH_VARS toml11_install_cmake_dir
-)
+if (toml11_INSTALL)
+    configure_package_config_file(
+        cmake/toml11Config.cmake.in
+        ${toml11_config}
+        INSTALL_DESTINATION ${toml11_install_cmake_dir}
+        PATH_VARS toml11_install_cmake_dir
+    )
 
-# Install config files
-install(FILES ${toml11_config} ${toml11_config_version}
-    DESTINATION ${toml11_install_cmake_dir}
-)
+    # Install config files
+    install(FILES ${toml11_config} ${toml11_config_version}
+        DESTINATION ${toml11_install_cmake_dir}
+    )
 
-# Install header files
-install(
-    FILES toml.hpp
-    DESTINATION "${toml11_install_include_dir}"
-)
-install(
-    DIRECTORY "toml"
-    DESTINATION "${toml11_install_include_dir}"
-    FILES_MATCHING PATTERN "*.hpp"
-)
+    # Install header files
+    install(
+        FILES toml.hpp
+        DESTINATION "${toml11_install_include_dir}"
+    )
+    install(
+        DIRECTORY "toml"
+        DESTINATION "${toml11_install_include_dir}"
+        FILES_MATCHING PATTERN "*.hpp"
+    )
 
-# Export targets and install them
-install(TARGETS toml11
-    EXPORT toml11Targets
-)
-install(EXPORT toml11Targets
-    FILE toml11Targets.cmake
-    DESTINATION ${toml11_install_cmake_dir}
-    NAMESPACE toml11::
-)
+    # Export targets and install them
+    install(TARGETS toml11
+        EXPORT toml11Targets
+    )
+    install(EXPORT toml11Targets
+        FILE toml11Targets.cmake
+        DESTINATION ${toml11_install_cmake_dir}
+        NAMESPACE toml11::
+    )
+endif()
 
 if (toml11_BUILD_TEST)
     add_subdirectory(tests)

README.md

@@ -1,6 +1,7 @@
 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)
@@ -8,16 +9,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 header-only toml parser/encoder depending only on C++ standard library.
+toml11 is a C++11 (or later) header-only toml parser/encoder depending only on C++ standard library.
 
-compatible to the latest version of
-[TOML v0.5.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.5.0.md)
-after version 2.0.0.
-
-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).
+- It is compatible to the latest version of [TOML v1.0.0](https://toml.io/en/v1.0.0).
+- 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.
 
 ## Example
 
@@ -27,15 +28,29 @@ You can see the error messages about invalid files and serialization results of
 
 int main()
 {
-    const auto data = toml::parse("example.toml");
-
+    // ```toml
     // title = "an example toml file"
-    std::string title = toml::find<std::string>(data, "title");
-    std::cout << "the title is " << title << std::endl;
+    // nums  = [3, 1, 4, 1, 5]
+    // ```
+    auto data = toml::parse("example.toml");
 
-    // 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;
+    // find a value with the specified type from a table
+    std::string title = toml::find<std::string>(data, "title");
+
+    // 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(!data.contains("foo"))
+    {
+        data["foo"] = "bar";
+    }
+
+    // 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;
 
     return 0;
 }
@@ -84,7 +99,7 @@ int main()
 Just include the file after adding it to the include path.
 
 ```cpp
-#include <toml11/toml.hpp> // that's all! now you can use it.
+#include <toml.hpp> // that's all! now you can use it.
 #include <iostream>
 
 int main()
@@ -99,6 +114,8 @@ 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
@@ -109,6 +126,9 @@ 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.
@@ -166,7 +186,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
 ```
@@ -231,7 +251,7 @@ See also [underlying types](#underlying-types).
 **NOTE**: For some technical reason, automatic conversion between `integer` and
 `floating` is not supported. If you want to get a floating value even if a value
 has integer value, you need to convert it manually after obtaining a value,
-like the followings.
+like the following.
 
 ```cpp
 const auto vx = toml::find(data, "x");
@@ -256,11 +276,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, "apple");
+const auto  name  = toml::find<std::string>(fruit, "name");
 
 const auto& physical = toml::find(fruit, "physical");
-const auto  color    = toml::find<std::string>(fruit, "color");
-const auto  shape    = toml::find<std::string>(fruit, "shape");
+const auto  color    = toml::find<std::string>(physical, "color");
+const auto  shape    = toml::find<std::string>(physical, "shape");
 ```
 
 Here, variable `fruit` is a `toml::value` and can be used as the first argument
@@ -452,6 +472,24 @@ 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
@@ -797,6 +835,19 @@ const auto data = toml::parse("example.toml");
 const auto num  = toml::find_or(data, "num", 42);
 ```
 
+It works recursively if you pass several keys for subtables.
+In that case, the last argument is considered to be the optional value.
+All other arguments between `toml::value` and the optinoal value are considered as keys.
+
+```cpp
+// [fruit.physical]
+// color = "red"
+auto data  = toml::parse("fruit.toml");
+auto color = toml::find_or(data, "fruit", "physical", "color", "red");
+//                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^
+//                               arguments                     optional value
+```
+
 Also, `toml::get_or` returns a default value if `toml::get<T>` failed.
 
 ```cpp
@@ -854,7 +905,7 @@ toml::visit([](const auto& val) -> void {
 ```
 
 The function object that would be passed to `toml::visit` must be able to
-recieve all the possible TOML types. Also, the result types should be the same
+receive all the possible TOML types. Also, the result types should be the same
 each other.
 
 ## Constructing a toml::value
@@ -920,13 +971,28 @@ v.push_back(6);
 
 ## Preserving comments
 
-After toml11 v3, you can choose whether comments are preserved or not.
+toml11 v3 or later allows you yo choose whether comments are preserved or not via template parameter
 
 ```cpp
 const auto data1 = toml::parse<toml::discard_comments >("example.toml");
 const auto data2 = toml::parse<toml::preserve_comments>("example.toml");
 ```
 
+or macro definition.
+
+```cpp
+#define TOML11_PRESERVE_COMMENTS_BY_DEFAULT
+#include <toml11/toml.hpp>
+```
+
+This feature is controlled by template parameter in `toml::basic_value<...>`.
+`toml::value` is an alias of `toml::basic_value<...>`.
+
+If template parameter is explicitly specified, the return value of `toml::parse`
+will be `toml::basic_value<toml::preserve_comments>`.
+If the macro is defined, the alias `toml::value` will be
+`toml::basic_value<toml::preserve_comments>`.
+
 Comments related to a value can be obtained by `toml::value::comments()`.
 The return value has the same interface as `std::vector<std::string>`.
 
@@ -1217,8 +1283,16 @@ struct from<ext::foo>
 In this way, since the conversion function is defined outside of the class,
 you can add conversion between `toml::value` and classes defined in another library.
 
-Note that you cannot implement both of the functions because the overload
-resolution of `toml::get` will be ambiguous.
+In some cases, a class has a templatized constructor that takes a template, `T`.
+It confuses `toml::get/find<T>` because it makes the class "constructible" from
+`toml::value`. To avoid this problem, `toml::from` and `from_toml` always
+precede constructor. It makes easier to implement conversion between
+`toml::value` and types defined in other libraries because it skips constructor.
+
+But, importantly, you cannot define `toml::from<T>` and `T.from_toml` at the same
+time because it causes ambiguity in the overload resolution of `toml::get<T>` and `toml::find<T>`.
+
+So the precedence is `toml::from<T>` == `T.from_toml()` > `T(toml::value)`.
 
 If you want to convert any versions of `toml::basic_value`,
 you need to templatize the conversion function as follows.
@@ -1269,9 +1343,9 @@ struct foo
     double      b;
     std::string c;
 
-    toml::table into_toml() const // you need to mark it const.
+    toml::value into_toml() const // you need to mark it const.
     {
-        return toml::table{{"a", this->a}, {"b", this->b}, {"c", this->c}};
+        return toml::value{{"a", this->a}, {"b", this->b}, {"c", this->c}};
     }
 };
 } // ext
@@ -1298,9 +1372,9 @@ namespace toml
 template<>
 struct into<ext::foo>
 {
-    static toml::table into_toml(const ext::foo& f)
+    static toml::value into_toml(const ext::foo& f)
     {
-        return toml::table{{"a", f.a}, {"b", f.b}, {"c", f.c}};
+        return toml::value{{"a", f.a}, {"b", f.b}, {"c", f.c}};
     }
 };
 } // toml
@@ -1312,6 +1386,55 @@ toml::value v(f);
 Any type that can be converted to `toml::value`, e.g. `int`, `toml::table` and
 `toml::array` are okay to return from `into_toml`.
 
+You can also return a custom `toml::basic_value` from `toml::into`.
+
+```cpp
+namespace toml
+{
+template<>
+struct into<ext::foo>
+{
+    static toml::basic_value<toml::preserve_comments> into_toml(const ext::foo& f)
+    {
+        toml::basic_value<toml::preserve_comments> v{{"a", f.a}, {"b", f.b}, {"c", f.c}};
+        v.comments().push_back(" comment");
+        return v;
+    }
+};
+} // toml
+```
+
+But note that, if this `basic_value` would be assigned into other `toml::value`
+that discards `comments`, the comments would be dropped.
+
+### Macro to automatically define conversion functions
+
+There is a helper macro that automatically generates conversion functions `from` and `into` for a simple struct.
+
+```cpp
+namespace foo
+{
+struct Foo
+{
+    std::string s;
+    double      d;
+    int         i;
+};
+} // foo
+
+TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i)
+
+int main()
+{
+    const auto file = toml::parse("example.toml");
+    auto f = toml::find<foo::Foo>(file, "foo");
+}
+```
+
+And then you can use `toml::find<foo::Foo>(file, "foo");`
+
+**Note** that, because of a slight difference in implementation of preprocessor between gcc/clang and MSVC, [you need to define `/Zc:preprocessor`](https://github.com/ToruNiina/toml11/issues/139#issuecomment-803683682) to use it in MSVC (Thank you @glebm !).
+
 ## Formatting user-defined error messages
 
 When you encounter an error after you read the toml value, you may want to
@@ -1413,7 +1536,7 @@ const toml::source_location loc = v.location();
 
 ## Exceptions
 
-All the exceptions thrown by toml11 inherits `toml::exception` that inherits
+The following `exception` classes inherits `toml::exception` that inherits
 `std::exception`.
 
 ```cpp
@@ -1440,6 +1563,16 @@ 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
@@ -1485,7 +1618,7 @@ it uses [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code).
 Without `TOML11_COLORIZE_ERROR_MESSAGE`, you can still colorize user-defined
 error message by passing `true` to the `toml::format_error` function.
 If you define `TOML11_COLORIZE_ERROR_MESSAGE`, the value is `true` by default.
-If not, the defalut value would be `false`.
+If not, the default value would be `false`.
 
 ```cpp
 std::cerr << toml::format_error("[error] value should be positive",
@@ -1586,7 +1719,7 @@ const std::string fmt = toml::format(v);
 ```
 
 To control the width and precision, `toml::format` receives optional second and
-third arguments to set them. By default, the witdh is 80 and the precision is
+third arguments to set them. By default, the width is 80 and the precision is
 `std::numeric_limits<double>::max_digit10`.
 
 ```cpp
@@ -1622,7 +1755,7 @@ flag that represents a kind of a string, `string_t::basic` and `string_t::litera
 Although `std::string` is not an exact toml type, still you can get a reference
 that points to internal `std::string` by using `toml::get<std::string>()` for convenience.
 The most important difference between `std::string` and `toml::string` is that
-`toml::string` will be formatted as a TOML string when outputed with `ostream`.
+`toml::string` will be formatted as a TOML string when outputted with `ostream`.
 This feature is introduced to make it easy to write a custom serializer.
 
 `Datetime` variants are `struct` that are defined in this library.
@@ -1631,13 +1764,8 @@ not capable of representing a Local Time independent from a specific day.
 
 ## Unreleased TOML features
 
-There are some unreleased features in toml-lang/toml:master.
-Currently, the following features are available after defining
-`TOML11_USE_UNRELEASED_TOML_FEATURES` macro flag.
-
-To use those features, `#define` `TOML11_USE_UNRELEASED_TOML_FEATURES` before
-including `toml.hpp` or pass `-DTOML11_USE_UNRELEASED_TOML_FEATURES` to your
-compiler.
+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`.
 
 - Leading zeroes in exponent parts of floats are permitted.
   - e.g. `1.0e+01`, `5e+05`
@@ -1647,10 +1775,10 @@ compiler.
 - 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.
+does not. Here the reason is explained.
 
 ```cpp
 // this won't be compiled
@@ -1659,8 +1787,10 @@ toml::value v{
 }
 ```
 
-There is a workaround for this issue. By explicitly converting values into
+There is a workaround for this. 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!
@@ -1668,6 +1798,17 @@ 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.
@@ -1696,15 +1837,14 @@ This means that the above C++ code makes constructor's overload resolution
 ambiguous. So a constructor that allows both "table as an initializer-list" and
 "heterogeneous array as an initializer-list" cannot be implemented.
 
-Thus, although it is painful, you need to explicitly cast values into
-`toml::value` when you initialize heterogeneous array in C++ code.
+Thus, although it is painful, we need to explicitly cast values into
+`toml::value` when you initialize heterogeneous array in a 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
@@ -1743,14 +1883,13 @@ Such a big change will not happen in the coming years.
 
 ## Running Tests
 
-To run test codes, you need to clone toml-lang/toml repository under `build/` directory
-because some of the test codes read a file in the repository.
+After cloning this repository, run the following command (thank you @jwillikers
+for automating test set fetching!).
 
 ```sh
 $ mkdir build
 $ cd build
-$ git clone https://github.com/toml-lang/toml.git
-$ cmake ..
+$ cmake .. -Dtoml11_BUILD_TEST=ON
 $ make
 $ make test
 ```
@@ -1767,12 +1906,12 @@ I appreciate the help of the contributors who introduced the great feature to th
   - Intel Compiler support
 - Quentin Khan (@xaxousis)
   - Found & Fixed a bug around ODR
-  - Improved error messages for invaild keys to show the location where the parser fails
+  - Improved error messages for invalid keys to show the location where the parser fails
 - Petr Beneš (@wbenny)
   - Fixed warnings on MSVC
 - Ivan Shynkarenka (@chronoxor)
   - Fixed Visual Studio 2019 warnings
-- @khoitd1997
+- Khoi Dinh Trinh (@khoitd1997)
   - Fixed warnings while type conversion
 - @KerstinKeller
   - Added installation script to CMake
@@ -1783,11 +1922,46 @@ 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
+- Ivan Shynkarenka (@chronoxor)
+  - Fix compilation error in `<filesystem>` with MinGW
+- Alex Merry (@amerry)
+  - Add missing include files
+- sneakypete81 (@sneakypete81)
+  - Fix typo in error message
+- Oliver Kahrmann (@founderio)
+  - Fix missing filename in error message if parsed file is empty
+- Karl Nilsson (@karl-nilsson)
+  - Fix many spelling errors
+- ohdarling88 (@ohdarling)
+  - Fix a bug in a constructor of serializer
+- estshorter (@estshorter)
+  - Fix MSVC warning C26478
+- Philip Top (@phlptp)
+  - Improve checking standard library feature availability check
+- Louis Marascio (@marascio)
+  - Fix free-nonheap-object warning
+- Axel Huebl (@ax3l)
+  - Make installation optional if the library is embedded
 
 ## Licensing terms
 
 This product is licensed under the terms of the [MIT License](LICENSE).
 
-- Copyright (c) 2017-2020 Toru Niina
+- Copyright (c) 2017-2022 Toru Niina
 
 All rights reserved.

appveyor.yml

@@ -17,10 +17,9 @@ build_script:
   - cd C:\toml11
   - mkdir build
   - cd build
-  - 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 -G"%generator%" -DBOOST_ROOT=C:/Libraries/boost_1_69_0 -Dtoml11_BUILD_TEST=ON ..
   - 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

tests/CMakeLists.txt

@@ -1,3 +1,12 @@
+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
@@ -27,6 +36,7 @@ set(TEST_NAMES
     test_get_or
     test_find
     test_find_or
+    test_find_or_recursive
     test_expect
     test_parse_file
     test_serialize_file
@@ -34,7 +44,6 @@ set(TEST_NAMES
     test_error_detection
     test_format_error
     test_extended_conversions
-    test_visit
 )
 
 CHECK_CXX_COMPILER_FLAG("-Wall"      COMPILER_SUPPORTS_WALL)
@@ -49,6 +58,9 @@ 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)
+CHECK_CXX_COMPILER_FLAG("-Wshadow"              COMPILER_SUPPORTS_WSHADOW)
 
 if(COMPILER_SUPPORTS_WALL)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
@@ -62,6 +74,9 @@ endif()
 if(COMPILER_SUPPORTS_WERROR)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
 endif()
+if(COMPILER_SUPPORTS_WSHADOW)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshadow")
+endif()
 if(COMPILER_SUPPORTS_WSIGN_CONVERSION)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-conversion")
 endif()
@@ -83,6 +98,12 @@ 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)
@@ -128,15 +149,57 @@ if(MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4820")
     # pragma warning(pop): likely mismatch, popping warning state pushed in different file
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd5031")
+	# pragma warning(pop): spectre warnings in tests
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd5045")
+	# pragma warning(pop): spectre warnings in tests
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4265")
 endif()
 
 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)
+    target_include_directories(${TEST_NAME} SYSTEM PRIVATE ${Boost_INCLUDE_DIRS})
+
+    # 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")
@@ -151,7 +214,7 @@ foreach(TEST_NAME ${TEST_NAMES})
         endif()
     endif()
 
-    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME} WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
+    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     # Set the PATH to be able to find Boost DLL
     if(WIN32)
@@ -162,8 +225,15 @@ 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()
+

tests/check_serialization.cpp

@@ -22,15 +22,40 @@ int main(int argc, char **argv)
 
         if(data != serialized)
         {
-            std::cerr << "============================================================\n";
-            std::cerr << "result (w/o comment) different: " << filename << std::endl;
-            std::cerr << "------------------------------------------------------------\n";
-            std::cerr << "# serialized\n";
-            std::cerr << serialized;
-            std::cerr << "------------------------------------------------------------\n";
-            std::cerr << "# data\n";
-            std::cerr << data;
-            return 1;
+            // this is really a ditry hack, but is the easiest way...
+            // TODO: cleanup by adding comparison function to check if a value is NaN or not
+            if(filename.substr(filename.size() - 22, 22) == "float-inf-and-nan.toml" &&
+                std::isnan   (toml::find<double>(serialized, "nan"))           &&
+               !std::signbit (toml::find<double>(serialized, "nan"))           &&
+                std::isnan   (toml::find<double>(serialized, "nan_plus"))      &&
+               !std::signbit (toml::find<double>(serialized, "nan_plus"))      &&
+                std::isnan   (toml::find<double>(serialized, "nan_neg"))       &&
+                std::signbit (toml::find<double>(serialized, "nan_neg"))       &&
+               !std::isnan   (toml::find<double>(serialized, "infinity"))      &&
+               !std::isfinite(toml::find<double>(serialized, "infinity"))      &&
+               !std::signbit (toml::find<double>(serialized, "infinity"))      &&
+               !std::isnan   (toml::find<double>(serialized, "infinity_plus")) &&
+               !std::isfinite(toml::find<double>(serialized, "infinity_plus")) &&
+               !std::signbit (toml::find<double>(serialized, "infinity_plus")) &&
+               !std::isnan   (toml::find<double>(serialized, "infinity_neg"))  &&
+               !std::isfinite(toml::find<double>(serialized, "infinity_neg"))  &&
+                std::signbit (toml::find<double>(serialized, "infinity_neg")))
+            {
+                // then it is correctly serialized.
+                // Note that, the result of (nan == nan) is false. so `data == serialized` is false.
+            }
+            else
+            {
+                std::cerr << "============================================================\n";
+                std::cerr << "result (w/o comment) different: " << filename << std::endl;
+                std::cerr << "------------------------------------------------------------\n";
+                std::cerr << "# serialized\n";
+                std::cerr << serialized;
+                std::cerr << "------------------------------------------------------------\n";
+                std::cerr << "# data\n";
+                std::cerr << data;
+                return 1;
+            }
         }
     }
     {
@@ -42,15 +67,46 @@ int main(int argc, char **argv)
         const auto serialized = toml::parse<toml::preserve_comments>("tmp.toml");
         if(data != serialized)
         {
-            std::cerr << "============================================================\n";
-            std::cerr << "result (w/  comment) different: " << filename << std::endl;
-            std::cerr << "------------------------------------------------------------\n";
-            std::cerr << "# serialized\n";
-            std::cerr << serialized;
-            std::cerr << "------------------------------------------------------------\n";
-            std::cerr << "# data\n";
-            std::cerr << data;
-            return 1;
+            // this is really a ditry hack, but is the easiest way...
+            // TODO: cleanup by adding comparison function to check if a value is NaN or not
+            if(filename.substr(filename.size() - 22, 22) == "float-inf-and-nan.toml" &&
+                std::isnan   (toml::find<double>(serialized, "nan"))           &&
+               !std::signbit (toml::find<double>(serialized, "nan"))           &&
+                std::isnan   (toml::find<double>(serialized, "nan_plus"))      &&
+               !std::signbit (toml::find<double>(serialized, "nan_plus"))      &&
+                std::isnan   (toml::find<double>(serialized, "nan_neg"))       &&
+                std::signbit (toml::find<double>(serialized, "nan_neg"))       &&
+               !std::isnan   (toml::find<double>(serialized, "infinity"))      &&
+               !std::isfinite(toml::find<double>(serialized, "infinity"))      &&
+               !std::signbit (toml::find<double>(serialized, "infinity"))      &&
+               !std::isnan   (toml::find<double>(serialized, "infinity_plus")) &&
+               !std::isfinite(toml::find<double>(serialized, "infinity_plus")) &&
+               !std::signbit (toml::find<double>(serialized, "infinity_plus")) &&
+               !std::isnan   (toml::find<double>(serialized, "infinity_neg"))  &&
+               !std::isfinite(toml::find<double>(serialized, "infinity_neg"))  &&
+                std::signbit (toml::find<double>(serialized, "infinity_neg"))  &&
+                toml::find(data, "nan").comments()           == toml::find(serialized, "nan").comments()           &&
+                toml::find(data, "nan_plus").comments()      == toml::find(serialized, "nan_plus").comments()      &&
+                toml::find(data, "nan_neg").comments()       == toml::find(serialized, "nan_neg").comments()       &&
+                toml::find(data, "infinity").comments()      == toml::find(serialized, "infinity").comments()      &&
+                toml::find(data, "infinity_plus").comments() == toml::find(serialized, "infinity_plus").comments() &&
+                toml::find(data, "infinity_neg").comments()  == toml::find(serialized, "infinity_neg").comments()  )
+            {
+                // then it is correctly serialized.
+                // Note that, the result of (nan == nan) is false. so `data == serialized` is false.
+            }
+            else
+            {
+                std::cerr << "============================================================\n";
+                std::cerr << "result (w/  comment) different: " << filename << std::endl;
+                std::cerr << "------------------------------------------------------------\n";
+                std::cerr << "# serialized\n";
+                std::cerr << serialized;
+                std::cerr << "------------------------------------------------------------\n";
+                std::cerr << "# data\n";
+                std::cerr << data;
+                return 1;
+            }
         }
     }
     return 0;

tests/check_toml_test.cpp

@@ -16,6 +16,14 @@ struct json_serializer
     }
     void operator()(toml::floating v)
     {
+        if(std::isnan(v) && std::signbit(v))
+        {
+            // toml-test does not allow negative NaN represented in "-nan" because
+            // there are languages that does not distinguish nan and -nan.
+            // But toml11 keeps sign from input. To resolve this difference,
+            // we convert -nan to nan here.
+            v = std::numeric_limits<toml::floating>::quiet_NaN();
+        }
         std::cout << "{\"type\":\"float\",\"value\":\"" << toml::value(v) << "\"}";
         return ;
     }
@@ -24,23 +32,24 @@ struct json_serializer
         // since toml11 automatically convert string to multiline string that is
         // valid only in TOML, we need to format the string to make it valid in
         // JSON.
-        std::cout << "{\"type\":\"string\",\"value\":\""
-                  << this->escape_string(v.str) << "\"}";
+        toml::serializer<toml::value> ser(std::numeric_limits<std::size_t>::max());
+        std::cout << "{\"type\":\"string\",\"value\":"
+                  << ser(v.str) << "}";
         return ;
     }
     void operator()(const toml::local_time& v)
     {
-        std::cout << "{\"type\":\"local_time\",\"value\":\"" << toml::value(v) << "\"}";
+        std::cout << "{\"type\":\"time-local\",\"value\":\"" << toml::value(v) << "\"}";
         return ;
     }
     void operator()(const toml::local_date& v)
     {
-        std::cout << "{\"type\":\"local_date\",\"value\":\"" << toml::value(v) << "\"}";
+        std::cout << "{\"type\":\"date-local\",\"value\":\"" << toml::value(v) << "\"}";
         return ;
     }
     void operator()(const toml::local_datetime& v)
     {
-        std::cout << "{\"type\":\"local_datetime\",\"value\":\"" << toml::value(v) << "\"}";
+        std::cout << "{\"type\":\"datetime-local\",\"value\":\"" << toml::value(v) << "\"}";
         return ;
     }
     void operator()(const toml::offset_datetime& v)
@@ -64,7 +73,8 @@ struct json_serializer
         }
         else
         {
-            std::cout << "{\"type\":\"array\",\"value\":[";
+//             std::cout << "{\"type\":\"array\",\"value\":[";
+            std::cout << "[";
             bool is_first = true;
             for(const auto& elem : v)
             {
@@ -72,7 +82,7 @@ struct json_serializer
                 is_first = false;
                 toml::visit(*this, elem);
             }
-            std::cout << "]}";
+            std::cout << "]";
         }
         return ;
     }
@@ -84,34 +94,20 @@ struct json_serializer
         {
             if(!is_first) {std::cout << ", ";}
             is_first = false;
-            std::cout << toml::format(toml::value(elem.first),
-                    std::numeric_limits<std::size_t>::max());
-            std::cout << ':';
+            const auto k = toml::format_key(elem.first);
+            if(k.at(0) == '"')
+            {
+                std::cout << k << ":";
+            }
+            else // bare key
+            {
+                std::cout << '\"' << k << "\":";
+            }
             toml::visit(*this, elem.second);
         }
         std::cout << '}';
         return ;
     }
-
-    std::string escape_string(const std::string& s) const
-    {
-        std::string retval;
-        for(const char c : s)
-        {
-            switch(c)
-            {
-                case '\\': {retval += "\\\\"; break;}
-                case '\"': {retval += "\\\""; break;}
-                case '\b': {retval += "\\b";  break;}
-                case '\t': {retval += "\\t";  break;}
-                case '\f': {retval += "\\f";  break;}
-                case '\n': {retval += "\\n";  break;}
-                case '\r': {retval += "\\r";  break;}
-                default  : {retval += c;      break;}
-            }
-        }
-        return retval;
-    }
 };
 
 int main()

tests/test_comments.cpp

@@ -11,7 +11,7 @@
 BOOST_AUTO_TEST_CASE(test_comment_before)
 {
     {
-        const std::string file = u8R"(
+        const std::string file = R"(
             # 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() == u8" comment for a.");
+        BOOST_TEST(a.comments().front() == " comment for a.");
         BOOST_TEST(b.comments().size()  == 1u);
-        BOOST_TEST(b.comments().front() == u8" comment for b.");
+        BOOST_TEST(b.comments().front() == " comment for b.");
     }
     {
-        const std::string file = u8R"(
+        const std::string file = R"(
             # 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() == u8" comment for a.");
-        BOOST_TEST(a.comments().back()  == u8" another comment for a.");
+        BOOST_TEST(a.comments().front() == " comment for a.");
+        BOOST_TEST(a.comments().back()  == " another comment for a.");
         BOOST_TEST(b.comments().size()  == 2u);
-        BOOST_TEST(b.comments().front() == u8" comment for b.");
-        BOOST_TEST(b.comments().back()  == u8" also comment for b.");
+        BOOST_TEST(b.comments().front() == " comment for b.");
+        BOOST_TEST(b.comments().back()  == " also comment for b.");
     }
 }
 
 BOOST_AUTO_TEST_CASE(test_comment_inline)
 {
     {
-        const std::string file = u8R"(
+        const std::string file = R"(
             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() == u8" comment for a.");
+        BOOST_TEST(a.comments().front() == " comment for a.");
         BOOST_TEST(b.comments().size()  == 1u);
-        BOOST_TEST(b.comments().front() == u8" comment for b.");
+        BOOST_TEST(b.comments().front() == " comment for b.");
     }
     {
-        const std::string file = u8R"(
+        const std::string file = R"(
             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()  == u8" comment for a.");
+        BOOST_TEST(a.comments().front()  == " comment for a.");
         BOOST_TEST(b.comments().size()   == 1u);
-        BOOST_TEST(b.comments().front()  == u8" this is a comment for b.");
+        BOOST_TEST(b.comments().front()  == " this is a comment for b.");
         BOOST_TEST(b0.comments().size()  == 1u);
-        BOOST_TEST(b0.comments().front() == u8" this is not a comment for b, but \"bar\"");
+        BOOST_TEST(b0.comments().front() == " this is not a comment for b, but \"bar\"");
     }
 }
 
 BOOST_AUTO_TEST_CASE(test_comment_both)
 {
     {
-        const std::string file = u8R"(
+        const std::string file = R"(
             # comment for a.
             a = 42 # inline comment for a.
             # comment for b.
@@ -122,25 +122,62 @@ 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() == u8" comment for a.");
-        BOOST_TEST(a.comments().back()  == u8" inline comment for a.");
+        BOOST_TEST(a.comments().front() == " comment for a.");
+        BOOST_TEST(a.comments().back()  == " inline comment for a.");
         BOOST_TEST(b.comments().size()  == 2u);
-        BOOST_TEST(b.comments().front() == u8" comment for b.");
-        BOOST_TEST(b.comments().back()  == u8" inline comment for b.");
+        BOOST_TEST(b.comments().front() == " comment for b.");
+        BOOST_TEST(b.comments().back()  == " inline comment for b.");
 
         BOOST_TEST(c.comments().size()  == 2u);
-        BOOST_TEST(c.comments().front() == u8" comment for c.");
-        BOOST_TEST(c.comments().back()  == u8" another comment for c.");
+        BOOST_TEST(c.comments().front() == " comment for c.");
+        BOOST_TEST(c.comments().back()  == " another comment for c.");
 
         BOOST_TEST(c0.comments().size()  == 2u);
-        BOOST_TEST(c0.comments().front() == u8" comment for the first element.");
-        BOOST_TEST(c0.comments().back()  == u8" this also.");
+        BOOST_TEST(c0.comments().front() == " comment for the first element.");
+        BOOST_TEST(c0.comments().back()  == " this also.");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_comments_on_implicit_values)
+{
+    {
+        const std::string file = R"(
+            # comment for the first element of array-of-tables.
+            [[array-of-tables]]
+            foo = "bar"
+        )";
+        std::istringstream iss(file);
+        const auto v = toml::parse<toml::preserve_comments>(iss);
+
+        const auto aot = toml::find(v, "array-of-tables");
+        const auto elm = aot.at(0);
+        BOOST_TEST(aot.comments().empty());
+        BOOST_TEST(elm.comments().size() == 1);
+        BOOST_TEST(elm.comments().front() == " comment for the first element of array-of-tables.");
+    }
+    {
+        const std::string file = R"(
+            # comment for the array itself
+            array-of-tables = [
+                # comment for the first element of array-of-tables.
+                {foo = "bar"}
+            ]
+        )";
+        std::istringstream iss(file);
+        const auto v = toml::parse<toml::preserve_comments>(iss);
+
+        const auto aot = toml::find(v, "array-of-tables");
+        const auto elm = aot.at(0);
+        BOOST_TEST(aot.comments().size() == 1);
+        BOOST_TEST(aot.comments().front() == " comment for the array itself");
+        BOOST_TEST(elm.comments().size() == 1);
+        BOOST_TEST(elm.comments().front() == " comment for the first element of array-of-tables.");
     }
 }
 
 BOOST_AUTO_TEST_CASE(test_discard_comment)
 {
-    const std::string file = u8R"(
+    const std::string file = R"(
         # comment for a.
         a = 42 # inline comment for a.
         # comment for b.
@@ -153,7 +190,7 @@ BOOST_AUTO_TEST_CASE(test_discard_comment)
     )";
 
     std::istringstream iss(file);
-    const auto v = toml::parse(iss);
+    const auto v = toml::parse<toml::discard_comments>(iss);
 
     const auto& a  = toml::find(v, "a");
     const auto& b  = toml::find(v, "b");
@@ -235,7 +272,7 @@ BOOST_AUTO_TEST_CASE(test_construct_value_with_comments)
         BOOST_TEST(v.is_string());
         BOOST_TEST(v.as_string() == "str");
     }
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
     {
         using namespace std::literals::string_view_literals;
         const value_type v("str"sv, {"comment1", "comment2"});

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_USE_UNRELEASED_TOML_FEATURES
-    BOOST_TEST_MESSAGE("heterogeneous array will be allowed in the next release");
-#else
+#ifdef TOML11_DISALLOW_HETEROGENEOUS_ARRAYS
     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
 }
 

tests/test_extended_conversions.cpp

@@ -47,8 +47,6 @@ 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"))
@@ -72,9 +70,9 @@ struct from<extlib::foo>
 template<>
 struct into<extlib::foo>
 {
-    static toml::table into_toml(const extlib::foo& f)
+    static toml::value into_toml(const extlib::foo& f)
     {
-        return toml::table{{"a", f.a}, {"b", f.b}};
+        return toml::value{{"a", f.a}, {"b", f.b}};
     }
 };
 
@@ -137,8 +135,6 @@ 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"))
@@ -488,5 +484,148 @@ 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");
+    }
+
 }
 
+// ===========================================================================
+
+#ifndef TOML11_WITHOUT_DEFINE_NON_INTRUSIVE
+
+namespace extlib3
+{
+struct foo
+{
+    int a;
+    std::string b;
+};
+struct bar
+{
+    int         a;
+    std::string b;
+    foo         f;
+};
+
+} // extlib3
+
+TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(extlib3::foo, a, b)
+TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(extlib3::bar, a, b, f)
+
+BOOST_AUTO_TEST_CASE(test_conversion_via_macro)
+{
+    {
+        const toml::value v{{"a", 42}, {"b", "baz"}};
+
+        const auto foo = toml::get<extlib3::foo>(v);
+        BOOST_TEST(foo.a == 42);
+        BOOST_TEST(foo.b == "baz");
+
+        const toml::value v2(foo);
+        BOOST_TEST(v2 == v);
+    }
+    {
+        const toml::basic_value<toml::discard_comments, std::map, std::deque> v{
+            {"a", 42}, {"b", "baz"}
+        };
+
+        const auto foo = toml::get<extlib3::foo>(v);
+        BOOST_TEST(foo.a == 42);
+        BOOST_TEST(foo.b == "baz");
+
+        const toml::basic_value<toml::discard_comments, std::map, std::deque> v2(foo);
+        BOOST_TEST(v2 == v);
+    }
+
+    // -----------------------------------------------------------------------
+
+    {
+        const toml::value v{
+            {"a", 42},
+            {"b", "bar.b"},
+            {"f", toml::table{{"a", 42}, {"b", "foo.b"}}}
+        };
+
+        const auto bar = toml::get<extlib3::bar>(v);
+        BOOST_TEST(bar.a == 42);
+        BOOST_TEST(bar.b == "bar.b");
+        BOOST_TEST(bar.f.a == 42);
+        BOOST_TEST(bar.f.b == "foo.b");
+
+        const toml::value v2(bar);
+        BOOST_TEST(v2 == v);
+    }
+    {
+        const toml::basic_value<toml::discard_comments, std::map, std::deque> v{
+            {"a", 42},
+            {"b", "bar.b"},
+            {"f", toml::table{{"a", 42}, {"b", "foo.b"}}}
+        };
+
+        const auto bar = toml::get<extlib3::bar>(v);
+        BOOST_TEST(bar.a == 42);
+        BOOST_TEST(bar.b == "bar.b");
+        BOOST_TEST(bar.f.a == 42);
+        BOOST_TEST(bar.f.b == "foo.b");
+
+        const toml::basic_value<toml::discard_comments, std::map, std::deque> v2(bar);
+        BOOST_TEST(v2 == v);
+    }
+}
+#endif // TOML11_WITHOUT_DEFINE_NON_INTRUSIVE

tests/test_find.cpp

@@ -13,13 +13,13 @@
 #include <list>
 #include <deque>
 #include <array>
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 #include <string_view>
 #endif
 #include <tuple>
 
 using test_value_types = std::tuple<
-    toml::value,
+    toml::basic_value<toml::discard_comments>,
     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>
@@ -477,7 +477,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_string_type, value_type, test_value_type
         BOOST_TEST("foo" == moved);
     }
 
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
     {
         value_type v{{"key", toml::string("foo", toml::string_t::basic)}};
         BOOST_TEST("foo" == toml::find<std::string_view>(v, "key"));

tests/test_find_or.cpp

@@ -12,12 +12,12 @@
 #include <deque>
 #include <array>
 #include <tuple>
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 #include <string_view>
 #endif
 
 using test_value_types = std::tuple<
-    toml::value,
+    toml::basic_value<toml::discard_comments>,
     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>

tests/test_find_or_recursive.cpp

@@ -0,0 +1,401 @@
+#define BOOST_TEST_MODULE "test_find_or_recursive"
+#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 <unordered_map>
+#include <list>
+#include <deque>
+#include <array>
+#include <tuple>
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
+#include <string_view>
+#endif
+
+using test_value_types = std::tuple<
+    toml::basic_value<toml::discard_comments>,
+    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>
+>;
+
+namespace test
+{
+template<typename charT, typename traits, typename T, typename Alloc>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const std::vector<T, Alloc>& v)
+{
+    os << "[ ";
+    for(const auto& i : v) {os << i << ' ';}
+    os << ']';
+    return os;
+}
+template<typename charT, typename traits, typename T, typename Alloc>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const std::deque<T, Alloc>& v)
+{
+    os << "[ ";
+    for(const auto& i : v) {os << i << ' ';}
+    os << ']';
+    return os;
+}
+template<typename charT, typename traits, typename T, typename Alloc>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const std::list<T, Alloc>& v)
+{
+    os << "[ ";
+    for(const auto& i : v) {os << i << ' ';}
+    os << ']';
+    return os;
+}
+template<typename charT, typename traits,
+         typename Key, typename Value, typename Comp, typename Alloc>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os,
+           const std::map<Key, Value, Comp, Alloc>& v)
+{
+    os << "[ ";
+    for(const auto& i : v) {os << '{' << i.first << ", " << i.second << "} ";}
+    os << ']';
+    return os;
+}
+template<typename charT, typename traits,
+         typename Key, typename Value, typename Hash, typename Eq, typename Alloc>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os,
+           const std::unordered_map<Key, Value, Hash, Eq, Alloc>& v)
+{
+    os << "[ ";
+    for(const auto& i : v) {os << '{' << i.first << ", " << i.second << "} ";}
+    os << ']';
+    return os;
+}
+} // test
+
+#define TOML11_TEST_FIND_OR_EXACT(toml_type, init_expr, opt_expr) \
+    {                                                             \
+        using namespace test;                                     \
+        const toml::toml_type init init_expr ;                    \
+        const toml::toml_type opt  opt_expr ;                     \
+        const value_type v{{"key1", value_type{{"key2", init}} }};\
+        BOOST_TEST(init != opt);                                  \
+        BOOST_TEST(init == toml::find_or(v, "key1", "key2", opt));\
+    }                                                             \
+    /**/
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_exact, value_type, test_value_types)
+{
+    TOML11_TEST_FIND_OR_EXACT(boolean,         ( true), (false))
+    TOML11_TEST_FIND_OR_EXACT(integer,         (   42), (   54))
+    TOML11_TEST_FIND_OR_EXACT(floating,        ( 3.14), ( 2.71))
+    TOML11_TEST_FIND_OR_EXACT(string,          ("foo"), ("bar"))
+    TOML11_TEST_FIND_OR_EXACT(local_time,      (12, 30, 45), (6, 0, 30))
+    TOML11_TEST_FIND_OR_EXACT(local_date,      (2019, toml::month_t::Apr, 1),
+                                               (1999, toml::month_t::Jan, 2))
+    TOML11_TEST_FIND_OR_EXACT(local_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30))
+            )
+    TOML11_TEST_FIND_OR_EXACT(offset_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45), toml::time_offset( 9, 0)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30), toml::time_offset(-3, 0))
+            )
+    {
+        const typename value_type::array_type init{1,2,3,4,5};
+        const typename value_type::array_type opt {6,7,8,9,10};
+        const value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        BOOST_TEST(init == toml::find_or(v, "key", opt));
+    }
+    {
+        const typename value_type::table_type init{{"key1", 42}, {"key2", "foo"}};
+        const typename value_type::table_type opt {{"key1", 54}, {"key2", "bar"}};
+        const value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        BOOST_TEST(init == toml::find_or(v, "key", opt));
+    }
+}
+#undef TOML11_TEST_FIND_OR_EXACT
+
+#define TOML11_TEST_FIND_OR_MOVE(toml_type, init_expr, opt_expr)   \
+    {                                                              \
+        using namespace test;                                      \
+        const toml::toml_type init init_expr ;                     \
+        toml::toml_type opt  opt_expr ;                            \
+        value_type v{{"key1", value_type{{"key2", init}} }};       \
+        BOOST_TEST(init != opt);                                   \
+        const auto moved = toml::find_or(std::move(v), "key1", "key2", std::move(opt));\
+        BOOST_TEST(init == moved);                                 \
+    }                                                              \
+    /**/
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_move, value_type, test_value_types)
+{
+    TOML11_TEST_FIND_OR_MOVE(boolean,         ( true), (false))
+    TOML11_TEST_FIND_OR_MOVE(integer,         (   42), (   54))
+    TOML11_TEST_FIND_OR_MOVE(floating,        ( 3.14), ( 2.71))
+    TOML11_TEST_FIND_OR_MOVE(string,          ("foo"), ("bar"))
+    TOML11_TEST_FIND_OR_MOVE(local_time,      (12, 30, 45), (6, 0, 30))
+    TOML11_TEST_FIND_OR_MOVE(local_date,      (2019, toml::month_t::Apr, 1),
+                                              (1999, toml::month_t::Jan, 2))
+    TOML11_TEST_FIND_OR_MOVE(local_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30))
+            )
+    TOML11_TEST_FIND_OR_MOVE(offset_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45), toml::time_offset( 9, 0)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30), toml::time_offset(-3, 0))
+            )
+    {
+        typename value_type::array_type init{1,2,3,4,5};
+        typename value_type::array_type opt {6,7,8,9,10};
+        value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));
+        BOOST_TEST(init == moved);
+    }
+    {
+        typename value_type::table_type init{{"key1", 42}, {"key2", "foo"}};
+        typename value_type::table_type opt {{"key1", 54}, {"key2", "bar"}};
+        value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));
+        BOOST_TEST(init == moved);
+    }
+}
+#undef TOML11_TEST_FIND_OR_MOVE
+
+
+#define TOML11_TEST_FIND_OR_MODIFY(toml_type, init_expr, opt_expr)\
+    {                                                             \
+        using namespace test;                                     \
+        const toml::toml_type init init_expr ;                    \
+        toml::toml_type       opt1 opt_expr ;                     \
+        toml::toml_type       opt2 opt_expr ;                     \
+        value_type v{{"key1", value_type{{"key2", init}} }};      \
+        BOOST_TEST(init != opt1);                                 \
+        toml::find_or(v, "key1", "key2", opt2) = opt1;            \
+        BOOST_TEST(opt1 == toml::find<toml::toml_type>(v, "key1", "key2"));\
+    }                                                             \
+    /**/
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_modify, value_type, test_value_types)
+{
+    TOML11_TEST_FIND_OR_MODIFY(boolean,         ( true), (false))
+    TOML11_TEST_FIND_OR_MODIFY(integer,         (   42), (   54))
+    TOML11_TEST_FIND_OR_MODIFY(floating,        ( 3.14), ( 2.71))
+    TOML11_TEST_FIND_OR_MODIFY(string,          ("foo"), ("bar"))
+    TOML11_TEST_FIND_OR_MODIFY(local_time,      (12, 30, 45), (6, 0, 30))
+    TOML11_TEST_FIND_OR_MODIFY(local_date,      (2019, toml::month_t::Apr, 1),
+                                              (1999, toml::month_t::Jan, 2))
+    TOML11_TEST_FIND_OR_MODIFY(local_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30))
+            )
+    TOML11_TEST_FIND_OR_MODIFY(offset_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45), toml::time_offset( 9, 0)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30), toml::time_offset(-3, 0))
+            )
+    {
+        typename value_type::array_type init{1,2,3,4,5};
+        typename value_type::array_type opt1{6,7,8,9,10};
+        typename value_type::array_type opt2{6,7,8,9,10};
+        BOOST_TEST(init != opt1);
+        value_type v{{"key", init}};
+        toml::find_or(v, "key", opt2) = opt1;
+        BOOST_TEST(opt1 == toml::find<typename value_type::array_type>(v, "key"));
+    }
+    {
+        typename value_type::table_type init{{"key1", 42}, {"key2", "foo"}};
+        typename value_type::table_type opt1{{"key1", 54}, {"key2", "bar"}};
+        typename value_type::table_type opt2{{"key1", 54}, {"key2", "bar"}};
+        value_type v{{"key", init}};
+        BOOST_TEST(init != opt1);
+        toml::find_or(v, "key", opt2) = opt1;
+        BOOST_TEST(opt1 == toml::find<typename value_type::table_type>(v, "key"));
+    }
+}
+#undef TOML11_TEST_FIND_OR_MODIFY
+
+#define TOML11_TEST_FIND_OR_FALLBACK(init_type, opt_type)                   \
+    {                                                                       \
+        using namespace test;                                               \
+        value_type v1{{"key1", value_type{{"key3", "foo"}}}};               \
+        BOOST_TEST(opt_type == toml::find_or(v1, "key1", "key2", opt_type));\
+        value_type v2{{"key1", "foo"}};                                     \
+        BOOST_TEST(opt_type == toml::find_or(v2, "key1", "key3", opt_type));\
+    }                                                                       \
+    /**/
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_fallback, value_type, test_value_types)
+{
+    const toml::boolean         boolean        (true);
+    const toml::integer         integer        (42);
+    const toml::floating        floating       (3.14);
+    const toml::string          string         ("foo");
+    const toml::local_time      local_time     (12, 30, 45);
+    const toml::local_date      local_date     (2019, toml::month_t::Apr, 1);
+    const toml::local_datetime  local_datetime (
+            toml::local_date(2019, toml::month_t::Apr, 1),
+            toml::local_time(12, 30, 45));
+    const toml::offset_datetime offset_datetime(
+            toml::local_date(2019, toml::month_t::Apr, 1),
+            toml::local_time(12, 30, 45), toml::time_offset( 9, 0));
+
+    using array_type = typename value_type::array_type;
+    using table_type = typename value_type::table_type;
+    const array_type array{1, 2, 3, 4, 5};
+    const table_type table{{"key1", 42}, {"key2", "foo"}};
+
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(boolean, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(integer, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(integer, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(integer, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(integer, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(integer, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(integer, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(integer, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(integer, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(integer, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(floating, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(floating, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(floating, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(floating, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(floating, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(floating, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(floating, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(floating, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(floating, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(string, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(string, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(string, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(string, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(string, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(string, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(string, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(string, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(string, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(local_time, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(local_date, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(local_datetime, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, array          );
+    TOML11_TEST_FIND_OR_FALLBACK(offset_datetime, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(array, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(array, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(array, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(array, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(array, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(array, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(array, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(array, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(array, table          );
+
+    TOML11_TEST_FIND_OR_FALLBACK(table, boolean        );
+    TOML11_TEST_FIND_OR_FALLBACK(table, integer        );
+    TOML11_TEST_FIND_OR_FALLBACK(table, floating       );
+    TOML11_TEST_FIND_OR_FALLBACK(table, string         );
+    TOML11_TEST_FIND_OR_FALLBACK(table, local_time     );
+    TOML11_TEST_FIND_OR_FALLBACK(table, local_date     );
+    TOML11_TEST_FIND_OR_FALLBACK(table, local_datetime );
+    TOML11_TEST_FIND_OR_FALLBACK(table, offset_datetime);
+    TOML11_TEST_FIND_OR_FALLBACK(table, array          );
+}
+#undef TOML11_TEST_FIND_OR_FALLBACK
+
+struct move_only_type
+{
+    explicit move_only_type(const std::string& n): name_(n) {}
+
+    void from_toml(const toml::value& v)
+    {
+        this->name_ = toml::find<std::string>(v, "name");
+        return;
+    }
+
+    move_only_type(): name_("default"){}
+    ~move_only_type() = default;
+    move_only_type(move_only_type&&)            = default;
+    move_only_type& operator=(move_only_type&&) = default;
+    move_only_type(const move_only_type&)            = delete;
+    move_only_type& operator=(const move_only_type&) = delete;
+
+    bool operator==(const move_only_type& other) const noexcept {return this->name_ == other.name_;}
+    bool operator!=(const move_only_type& other) const noexcept {return this->name_ != other.name_;}
+    bool operator< (const move_only_type& other) const noexcept {return this->name_ <  other.name_;}
+    bool operator<=(const move_only_type& other) const noexcept {return this->name_ <= other.name_;}
+    bool operator> (const move_only_type& other) const noexcept {return this->name_ >  other.name_;}
+    bool operator>=(const move_only_type& other) const noexcept {return this->name_ >= other.name_;}
+
+    std::string name_;
+};
+
+std::ostream& operator<<(std::ostream& os, const move_only_type& mot)
+{
+    os << mot.name_;
+    return os;
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_move_only, value_type, test_value_types)
+{
+    const move_only_type ref("reference");
+    move_only_type opt("optional");
+    {
+        const value_type v{{"key1", value_type{{"key2", value_type{{"name", "reference"}} }} }};
+        BOOST_TEST(ref == toml::find_or(v, "key1", "key2", std::move(opt)));
+    }
+}
+
+
+
+
+

tests/test_get.cpp

@@ -12,12 +12,12 @@
 #include <deque>
 #include <array>
 #include <tuple>
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 #include <string_view>
 #endif
 
 using test_value_types = std::tuple<
-    toml::value,
+    toml::basic_value<toml::discard_comments>,
     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>
@@ -224,7 +224,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_string_type, value_type, test_value_types
         BOOST_TEST("foobar" == x);
     }
 
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
     {
         value_type v("foo", toml::string_t::basic);
         BOOST_TEST("foo" == toml::get<std::string_view>(v));

tests/test_get_or.cpp

@@ -12,12 +12,12 @@
 #include <deque>
 #include <array>
 #include <tuple>
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 #include <string_view>
 #endif
 
 using test_value_types = std::tuple<
-    toml::value,
+    toml::basic_value<toml::discard_comments>,
     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>

tests/test_lex_aux.hpp

@@ -8,7 +8,7 @@
 do {                                                                           \
     const std::string token   (tkn);                                           \
     const std::string expected(expct);                                         \
-    toml::detail::location<std::string> loc("test", token);                    \
+    toml::detail::location 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<std::string> loc("test", token);                    \
+    toml::detail::location loc("test", token);                                 \
     const auto result = lxr::invoke(loc);                                      \
     BOOST_TEST(result.is_err());                                               \
     const bool loc_same = (loc.begin() == loc.iter());                         \

tests/test_lex_key_comment.cpp

@@ -18,12 +18,11 @@ 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\"");
-#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+
+    // UTF-8 codepoint of characters that looks like "key" written upside down
     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\"'");
 }

tests/test_lex_string.cpp

@@ -31,15 +31,9 @@ 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\"",
-            "\"\xE4\xB8\xAD\xE5\x9B\xBD\"");
-#else
-    TOML11_TEST_LEX_ACCEPT(lex_string,
-            u8"\"中国\"",
-            u8"\"中国\"");
-#endif
+            "\"\xE4\xB8\xAD\xE5\x9B\xBD\"",  // UTF-8 string (means "China" in
+            "\"\xE4\xB8\xAD\xE5\x9B\xBD\""); // Chinese characters)
 
     TOML11_TEST_LEX_ACCEPT(lex_string,
             "\"You'll hate me after this - #\"",
@@ -57,6 +51,22 @@ 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)
@@ -83,4 +93,16 @@ 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.''''");
 }

tests/test_literals.cpp

@@ -12,6 +12,170 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
 {
     using namespace toml::literals::toml_literals;
 
+    {
+        const toml::value r{{"a", 42}, {"b", "baz"}};
+        const toml::value v = R"(
+            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 = R"(
+            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 = R"(
+            [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 = R"(
+            [[array_of_tables]]
+        )"_toml;
+
+        BOOST_TEST(r == v);
+    }
+}
+
+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"(
@@ -59,7 +223,7 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
     }
 }
 
-BOOST_AUTO_TEST_CASE(test_value_as_literal)
+BOOST_AUTO_TEST_CASE(test_value_as_u8_literal)
 {
     using namespace toml::literals::toml_literals;
 
@@ -98,15 +262,18 @@ BOOST_AUTO_TEST_CASE(test_value_as_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");
     }
     {
         {
@@ -164,7 +331,7 @@ BOOST_AUTO_TEST_CASE(test_value_as_literal)
                                  toml::local_time(7, 32, 0)));
     }
     {
-        const toml::value v1 = "1979-05-27T07:32:00Z"_toml;
+        const toml::value v1 = u8"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),

tests/test_parse_array.cpp

@@ -71,62 +71,153 @@ BOOST_AUTO_TEST_CASE(test_oneline_array_value)
 
 BOOST_AUTO_TEST_CASE(test_multiline_array)
 {
-    TOML11_TEST_PARSE_EQUAL(parse_array<toml::value>, "[\n#comment\n]", array());
+    TOML11_TEST_PARSE_EQUAL(parse_array<basic_value< discard_comments>>, "[\n#comment\n]", typename basic_value< discard_comments>::array_type());
+    TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<preserve_comments>>, "[\n#comment\n]", typename basic_value<preserve_comments>::array_type());
+
     {
-        array a(5);
-        a[0] = toml::value(3); a[1] = toml::value(1); a[2] = toml::value(4);
-        a[3] = toml::value(1); a[4] = toml::value(5);
-        TOML11_TEST_PARSE_EQUAL(parse_array<toml::value>, "[3,\n1,\n4,\n1,\n5]", a);
+        typename basic_value<discard_comments>::array_type a(5);
+        a[0] = basic_value<discard_comments>(3);
+        a[1] = basic_value<discard_comments>(1);
+        a[2] = basic_value<discard_comments>(4);
+        a[3] = basic_value<discard_comments>(1);
+        a[4] = basic_value<discard_comments>(5);
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<discard_comments>>, "[3,\n1,\n4,\n1,\n5]", a);
     }
     {
-        array a(3);
-        a[0] = toml::value("foo"); a[1] = toml::value("bar");
-        a[2] = toml::value("baz");
-        TOML11_TEST_PARSE_EQUAL(parse_array<toml::value>, "[\"foo\",\n\"bar\",\n\"baz\"]", a);
+        typename basic_value<preserve_comments>::array_type a(5);
+        a[0] = basic_value<preserve_comments>(3);
+        a[1] = basic_value<preserve_comments>(1);
+        a[2] = basic_value<preserve_comments>(4);
+        a[3] = basic_value<preserve_comments>(1);
+        a[4] = basic_value<preserve_comments>(5);
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<preserve_comments>>, "[3,\n1,\n4,\n1,\n5]", a);
     }
 
     {
-        array a(5);
-        a[0] = toml::value(3); a[1] = toml::value(1); a[2] = toml::value(4);
-        a[3] = toml::value(1); a[4] = toml::value(5);
-        TOML11_TEST_PARSE_EQUAL(parse_array<toml::value>, "[3,#comment\n1,#comment\n4,#comment\n1,#comment\n5]", a);
+        typename basic_value<discard_comments>::array_type a(5);
+        a[0] = basic_value<discard_comments>(3);
+        a[1] = basic_value<discard_comments>(1);
+        a[2] = basic_value<discard_comments>(4);
+        a[3] = basic_value<discard_comments>(1);
+        a[4] = basic_value<discard_comments>(5);
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<discard_comments>>, "[3,#comment\n1,#comment\n4,#comment\n1,#comment\n5 #comment\n]", a);
     }
     {
-        array a(3);
-        a[0] = toml::value("foo"); a[1] = toml::value("b#r");
-        a[2] = toml::value("b#z");
-        TOML11_TEST_PARSE_EQUAL(parse_array<toml::value>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", a);
+        typename basic_value<preserve_comments>::array_type a(5);
+        a[0] = basic_value<preserve_comments>(3, {"comment"});
+        a[1] = basic_value<preserve_comments>(1, {"comment"});
+        a[2] = basic_value<preserve_comments>(4, {"comment"});
+        a[3] = basic_value<preserve_comments>(1, {"comment"});
+        a[4] = basic_value<preserve_comments>(5, {"comment"});
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<preserve_comments>>, "[3,#comment\n1,#comment\n4,#comment\n1,#comment\n5 #comment\n]", a);
+    }
+
+
+    {
+        typename basic_value<discard_comments>::array_type a(3);
+        a[0] = basic_value<discard_comments>("foo");
+        a[1] = basic_value<discard_comments>("bar");
+        a[2] = basic_value<discard_comments>("baz");
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<discard_comments>>, "[\"foo\",\n\"bar\",\n\"baz\"]", a);
+    }
+    {
+        typename basic_value<preserve_comments>::array_type a(3);
+        a[0] = basic_value<preserve_comments>("foo");
+        a[1] = basic_value<preserve_comments>("bar");
+        a[2] = basic_value<preserve_comments>("baz");
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<preserve_comments>>, "[\"foo\",\n\"bar\",\n\"baz\"]", a);
+    }
+
+    {
+        typename basic_value<discard_comments>::array_type a(3);
+        a[0] = basic_value<discard_comments>("foo");
+        a[1] = basic_value<discard_comments>("b#r");
+        a[2] = basic_value<discard_comments>("b#z");
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<discard_comments>>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", a);
+    }
+    {
+        typename basic_value<preserve_comments>::array_type a(3);
+        a[0] = basic_value<preserve_comments>("foo", {"comment"});
+        a[1] = basic_value<preserve_comments>("b#r", {"comment"});
+        a[2] = basic_value<preserve_comments>("b#z", {"comment"});
+        TOML11_TEST_PARSE_EQUAL(parse_array<basic_value<preserve_comments>>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", a);
     }
 }
 
 BOOST_AUTO_TEST_CASE(test_multiline_array_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\n#comment\n]", toml::value(array()));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value< discard_comments>>, "[\n#comment\n]", basic_value< discard_comments>(typename basic_value< discard_comments>::array_type()));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<preserve_comments>>, "[\n#comment\n]", basic_value<preserve_comments>(typename basic_value<preserve_comments>::array_type()));
+
     {
-        array a(5);
-        a[0] = toml::value(3); a[1] = toml::value(1); a[2] = toml::value(4);
-        a[3] = toml::value(1); a[4] = toml::value(5);
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[3,\n1,\n4,\n1,\n5]", toml::value(a));
+        typename basic_value<discard_comments>::array_type a(5);
+        a[0] = basic_value<discard_comments>(3);
+        a[1] = basic_value<discard_comments>(1);
+        a[2] = basic_value<discard_comments>(4);
+        a[3] = basic_value<discard_comments>(1);
+        a[4] = basic_value<discard_comments>(5);
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<discard_comments>>, "[3,\n1,\n4,\n1,\n5]", basic_value<discard_comments>(a));
     }
     {
-        array a(3);
-        a[0] = toml::value("foo"); a[1] = toml::value("bar");
-        a[2] = toml::value("baz");
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",\n\"bar\",\n\"baz\"]", toml::value(a));
+        typename basic_value<preserve_comments>::array_type a(5);
+        a[0] = basic_value<preserve_comments>(3);
+        a[1] = basic_value<preserve_comments>(1);
+        a[2] = basic_value<preserve_comments>(4);
+        a[3] = basic_value<preserve_comments>(1);
+        a[4] = basic_value<preserve_comments>(5);
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<preserve_comments>>, "[3,\n1,\n4,\n1,\n5]", basic_value<preserve_comments>(a));
     }
 
     {
-        array a(5);
-        a[0] = toml::value(3); a[1] = toml::value(1); a[2] = toml::value(4);
-        a[3] = toml::value(1); a[4] = toml::value(5);
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[3,#comment\n1,#comment\n4,#comment\n1,#comment\n5]", toml::value(a));
+        typename basic_value<discard_comments>::array_type a(5);
+        a[0] = basic_value<discard_comments>(3);
+        a[1] = basic_value<discard_comments>(1);
+        a[2] = basic_value<discard_comments>(4);
+        a[3] = basic_value<discard_comments>(1);
+        a[4] = basic_value<discard_comments>(5);
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<discard_comments>>, "[3,#comment\n1,#comment\n4,#comment\n1,#comment\n5 #comment\n]", basic_value<discard_comments>(a));
     }
     {
-        array a(3);
-        a[0] = toml::value("foo"); a[1] = toml::value("b#r");
-        a[2] = toml::value("b#z");
-        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", toml::value(a));
+        typename basic_value<preserve_comments>::array_type a(5);
+        a[0] = basic_value<preserve_comments>(3, {"comment"});
+        a[1] = basic_value<preserve_comments>(1, {"comment"});
+        a[2] = basic_value<preserve_comments>(4, {"comment"});
+        a[3] = basic_value<preserve_comments>(1, {"comment"});
+        a[4] = basic_value<preserve_comments>(5, {"comment"});
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<preserve_comments>>, "[3,#comment\n1,#comment\n4,#comment\n1,#comment\n5 #comment\n]", basic_value<preserve_comments>(a));
     }
+
+
+    {
+        typename basic_value<discard_comments>::array_type a(3);
+        a[0] = basic_value<discard_comments>("foo");
+        a[1] = basic_value<discard_comments>("bar");
+        a[2] = basic_value<discard_comments>("baz");
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<discard_comments>>, "[\"foo\",\n\"bar\",\n\"baz\"]", basic_value<discard_comments>(a));
+    }
+    {
+        typename basic_value<preserve_comments>::array_type a(3);
+        a[0] = basic_value<preserve_comments>("foo");
+        a[1] = basic_value<preserve_comments>("bar");
+        a[2] = basic_value<preserve_comments>("baz");
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<preserve_comments>>, "[\"foo\",\n\"bar\",\n\"baz\"]", basic_value<preserve_comments>(a));
+    }
+
+    {
+        typename basic_value<discard_comments>::array_type a(3);
+        a[0] = basic_value<discard_comments>("foo");
+        a[1] = basic_value<discard_comments>("b#r");
+        a[2] = basic_value<discard_comments>("b#z");
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<discard_comments>>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", basic_value<discard_comments>(a));
+    }
+    {
+        typename basic_value<preserve_comments>::array_type a(3);
+        a[0] = basic_value<preserve_comments>("foo", {"comment"});
+        a[1] = basic_value<preserve_comments>("b#r", {"comment"});
+        a[2] = basic_value<preserve_comments>("b#z", {"comment"});
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<preserve_comments>>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", basic_value<preserve_comments>(a));
+    }
+
 }
 
 BOOST_AUTO_TEST_CASE(test_heterogeneous_array)
@@ -172,3 +263,31 @@ BOOST_AUTO_TEST_CASE(test_heterogeneous_array)
     }
 #endif
 }
+
+BOOST_AUTO_TEST_CASE(test_comments_after_comma)
+{
+    {
+        typename basic_value<discard_comments>::array_type a(3);
+        a[0] = basic_value<discard_comments>("foo");
+        a[1] = basic_value<discard_comments>("bar");
+        a[2] = basic_value<discard_comments>("baz");
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<discard_comments>>,
+            "[ \"foo\" # comment\n"
+            ", \"bar\" # comment\n"
+            ", \"baz\" # comment\n"
+            "]", basic_value<discard_comments>(a));
+    }
+
+    {
+        typename basic_value<preserve_comments>::array_type a(3);
+        a[0] = basic_value<preserve_comments>("foo", {" comment"});
+        a[1] = basic_value<preserve_comments>("bar", {" comment"});
+        a[2] = basic_value<preserve_comments>("baz", {" comment"});
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<basic_value<preserve_comments>>,
+            "[ \"foo\" # comment\n"
+            ", \"bar\" # comment\n"
+            ", \"baz\" # comment\n"
+            "]", basic_value<preserve_comments>(a));
+    }
+
+}

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<std::string> loc("test", token);                    \
+    toml::detail::location 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<std::string> loc("test", token);                    \
+    toml::detail::location loc("test", token);                                 \
     const auto result = psr(loc);                                              \
     BOOST_TEST(result.is_ok());                                                \
     if(result.is_ok()){                                                        \

tests/test_parse_datetime.cpp

@@ -17,6 +17,11 @@ BOOST_AUTO_TEST_CASE(test_time)
     TOML11_TEST_PARSE_EQUAL(parse_local_time, "07:32:00.99",     toml::local_time(7, 32, 0, 990, 0));
     TOML11_TEST_PARSE_EQUAL(parse_local_time, "07:32:00.999",    toml::local_time(7, 32, 0, 999, 0));
     TOML11_TEST_PARSE_EQUAL(parse_local_time, "07:32:00.999999", toml::local_time(7, 32, 0, 999, 999));
+
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_time, "00:00:00.000000", toml::local_time( 0,  0,  0,   0,   0));
+    TOML11_TEST_PARSE_EQUAL(parse_local_time, "23:59:59.999999", toml::local_time(23, 59, 59, 999, 999));
+    TOML11_TEST_PARSE_EQUAL(parse_local_time, "23:59:60.999999", toml::local_time(23, 59, 60, 999, 999)); // leap second
 }
 
 BOOST_AUTO_TEST_CASE(test_time_value)
@@ -25,17 +30,125 @@ BOOST_AUTO_TEST_CASE(test_time_value)
     TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "07:32:00.99",     toml::value(toml::local_time(7, 32, 0, 990, 0)));
     TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "07:32:00.999",    toml::value(toml::local_time(7, 32, 0, 999, 0)));
     TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "07:32:00.999999", toml::value(toml::local_time(7, 32, 0, 999, 999)));
+
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "00:00:00.000000", toml::value(toml::local_time( 0,  0,  0,   0,   0)));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "23:59:59.999999", toml::value(toml::local_time(23, 59, 59, 999, 999)));
+
+    std::istringstream stream1(std::string("invalid-datetime = 24:00:00"));
+    std::istringstream stream2(std::string("invalid-datetime = 00:60:00"));
+    std::istringstream stream3(std::string("invalid-datetime = 00:00:61"));
+    BOOST_CHECK_THROW(toml::parse(stream1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream2), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream3), toml::syntax_error);
 }
 
 BOOST_AUTO_TEST_CASE(test_date)
 {
-    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "1979-05-27",
-                            toml::local_date(1979, toml::month_t::May, 27));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "1979-05-27", toml::local_date(1979, toml::month_t::May, 27));
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-01-01", toml::local_date(2000, toml::month_t::Jan,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-01-31", toml::local_date(2000, toml::month_t::Jan, 31));
+    std::istringstream stream1_1(std::string("invalid-datetime = 2000-01-00"));
+    std::istringstream stream1_2(std::string("invalid-datetime = 2000-01-32"));
+    BOOST_CHECK_THROW(toml::parse(stream1_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream1_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-02-01", toml::local_date(2000, toml::month_t::Feb,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-02-29", toml::local_date(2000, toml::month_t::Feb, 29));
+    std::istringstream stream2_1(std::string("invalid-datetime = 2000-02-00"));
+    std::istringstream stream2_2(std::string("invalid-datetime = 2000-02-30"));
+    BOOST_CHECK_THROW(toml::parse(stream2_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream2_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2001-02-28", toml::local_date(2001, toml::month_t::Feb, 28));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2004-02-29", toml::local_date(2004, toml::month_t::Feb, 29));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2100-02-28", toml::local_date(2100, toml::month_t::Feb, 28));
+    std::istringstream stream2_3(std::string("invalid-datetime = 2001-02-29"));
+    std::istringstream stream2_4(std::string("invalid-datetime = 2004-02-30"));
+    std::istringstream stream2_5(std::string("invalid-datetime = 2100-02-29"));
+    BOOST_CHECK_THROW(toml::parse(stream2_3), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream2_4), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream2_5), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-03-01", toml::local_date(2000, toml::month_t::Mar,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-03-31", toml::local_date(2000, toml::month_t::Mar, 31));
+    std::istringstream stream3_1(std::string("invalid-datetime = 2000-03-00"));
+    std::istringstream stream3_2(std::string("invalid-datetime = 2000-03-32"));
+    BOOST_CHECK_THROW(toml::parse(stream3_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream3_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-04-01", toml::local_date(2000, toml::month_t::Apr,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-04-30", toml::local_date(2000, toml::month_t::Apr, 30));
+    std::istringstream stream4_1(std::string("invalid-datetime = 2000-04-00"));
+    std::istringstream stream4_2(std::string("invalid-datetime = 2000-04-31"));
+    BOOST_CHECK_THROW(toml::parse(stream4_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream4_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-05-01", toml::local_date(2000, toml::month_t::May,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-05-31", toml::local_date(2000, toml::month_t::May, 31));
+    std::istringstream stream5_1(std::string("invalid-datetime = 2000-05-00"));
+    std::istringstream stream5_2(std::string("invalid-datetime = 2000-05-32"));
+    BOOST_CHECK_THROW(toml::parse(stream5_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream5_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-06-01", toml::local_date(2000, toml::month_t::Jun,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-06-30", toml::local_date(2000, toml::month_t::Jun, 30));
+    std::istringstream stream6_1(std::string("invalid-datetime = 2000-06-00"));
+    std::istringstream stream6_2(std::string("invalid-datetime = 2000-06-31"));
+    BOOST_CHECK_THROW(toml::parse(stream6_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream6_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-07-01", toml::local_date(2000, toml::month_t::Jul,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-07-31", toml::local_date(2000, toml::month_t::Jul, 31));
+    std::istringstream stream7_1(std::string("invalid-datetime = 2000-07-00"));
+    std::istringstream stream7_2(std::string("invalid-datetime = 2000-07-32"));
+    BOOST_CHECK_THROW(toml::parse(stream7_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream7_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-08-01", toml::local_date(2000, toml::month_t::Aug,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-08-31", toml::local_date(2000, toml::month_t::Aug, 31));
+    std::istringstream stream8_1(std::string("invalid-datetime = 2000-08-00"));
+    std::istringstream stream8_2(std::string("invalid-datetime = 2000-08-32"));
+    BOOST_CHECK_THROW(toml::parse(stream8_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream8_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-09-01", toml::local_date(2000, toml::month_t::Sep,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-09-30", toml::local_date(2000, toml::month_t::Sep, 30));
+    std::istringstream stream9_1(std::string("invalid-datetime = 2000-09-00"));
+    std::istringstream stream9_2(std::string("invalid-datetime = 2000-09-31"));
+    BOOST_CHECK_THROW(toml::parse(stream9_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream9_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-10-01", toml::local_date(2000, toml::month_t::Oct,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-10-31", toml::local_date(2000, toml::month_t::Oct, 31));
+    std::istringstream stream10_1(std::string("invalid-datetime = 2000-10-00"));
+    std::istringstream stream10_2(std::string("invalid-datetime = 2000-10-32"));
+    BOOST_CHECK_THROW(toml::parse(stream10_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream10_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-11-01", toml::local_date(2000, toml::month_t::Nov,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-11-30", toml::local_date(2000, toml::month_t::Nov, 30));
+    std::istringstream stream11_1(std::string("invalid-datetime = 2000-11-00"));
+    std::istringstream stream11_2(std::string("invalid-datetime = 2000-11-31"));
+    BOOST_CHECK_THROW(toml::parse(stream11_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream11_2), toml::syntax_error);
+
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-12-01", toml::local_date(2000, toml::month_t::Dec,  1));
+    TOML11_TEST_PARSE_EQUAL(parse_local_date,  "2000-12-31", toml::local_date(2000, toml::month_t::Dec, 31));
+    std::istringstream stream12_1(std::string("invalid-datetime = 2000-12-00"));
+    std::istringstream stream12_2(std::string("invalid-datetime = 2000-12-32"));
+    BOOST_CHECK_THROW(toml::parse(stream12_1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream12_2), toml::syntax_error);
+
+    std::istringstream stream13_1(std::string("invalid-datetime = 2000-13-01"));
+    BOOST_CHECK_THROW(toml::parse(stream13_1), toml::syntax_error);
+    std::istringstream stream0_1(std::string("invalid-datetime = 2000-00-01"));
+    BOOST_CHECK_THROW(toml::parse(stream0_1), toml::syntax_error);
 }
+
 BOOST_AUTO_TEST_CASE(test_date_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1979-05-27",
-                            value(toml::local_date(1979, toml::month_t::May, 27)));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1979-05-27", value(toml::local_date(1979, toml::month_t::May, 27)));
 }
 
 BOOST_AUTO_TEST_CASE(test_datetime)
@@ -107,6 +220,11 @@ BOOST_AUTO_TEST_CASE(test_offset_datetime)
     TOML11_TEST_PARSE_EQUAL(parse_offset_datetime, "1979-05-27T07:32:00.999999+09:00",
         toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
                               toml::local_time(7, 32, 0, 999, 999), toml::time_offset(9, 0)));
+
+    std::istringstream stream1(std::string("invalid-datetime = 2000-01-01T00:00:00+24:00"));
+    std::istringstream stream2(std::string("invalid-datetime = 2000-01-01T00:00:00+00:60"));
+    BOOST_CHECK_THROW(toml::parse(stream1), toml::syntax_error);
+    BOOST_CHECK_THROW(toml::parse(stream2), toml::syntax_error);
 }
 
 BOOST_AUTO_TEST_CASE(test_offset_datetime_value)

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::ifstream ifs("toml/tests/example.toml", std::ios::binary);
     const auto data = toml::parse(ifs);
 
     BOOST_TEST(toml::find<std::string>(data, "title") == "TOML Example");
@@ -779,6 +779,22 @@ 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
 
@@ -889,3 +905,57 @@ BOOST_AUTO_TEST_CASE(test_files_end_with_empty_lines)
     }
 }
 
+BOOST_AUTO_TEST_CASE(test_file_ends_without_lf)
+{
+    {
+        const std::string table(
+            "key = \"value\"\n"
+            "[table]\n"
+            "key = \"value\""
+            );
+        std::istringstream iss(table);
+        const auto data = toml::parse(iss,
+                "test_files_end_without_lf.toml");
+
+        BOOST_TEST(toml::find<std::string>(data, "key") == "value");
+        BOOST_TEST(toml::find<std::string>(toml::find(data, "table"), "key") == "value");
+    }
+}
+
+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
+}

tests/test_parse_floating.cpp

@@ -128,7 +128,7 @@ BOOST_AUTO_TEST_CASE(test_inf)
 {
     {
         const std::string token("inf");
-        toml::detail::location<std::string> loc("test", token);
+        toml::detail::location 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<std::string> loc("test", token);
+        toml::detail::location 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<std::string> loc("test", token);
+        toml::detail::location 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<std::string> loc("test", token);
+        toml::detail::location 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<std::string> loc("test", token);
+        toml::detail::location 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<std::string> loc("test", token);
+        toml::detail::location loc("test", token);
         const auto r = parse_floating(loc);
         BOOST_CHECK(r.is_ok());
         BOOST_CHECK(std::isnan(r.unwrap().first));

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,14 +69,17 @@ 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)
@@ -84,16 +87,19 @@ 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)
@@ -104,16 +110,41 @@ 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)
@@ -134,16 +165,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));
 }
@@ -156,16 +187,34 @@ 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)

tests/test_parse_table.cpp

@@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE(test_normal_table)
         "key2 = 42\n"
         "key3 = 3.14\n"
         );
-    location<std::string> loc("test", table);
+    location 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<std::string> loc("test", table);
+    location loc("test", table);
 
     const auto result = toml::detail::parse_ml_table<toml::value>(loc);
     BOOST_TEST(result.is_ok());

tests/test_parse_unicode.cpp

@@ -9,7 +9,6 @@
 #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");
@@ -40,35 +39,3 @@ 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

tests/test_serialize_file.cpp

@@ -10,6 +10,7 @@
 #include <map>
 #include <iostream>
 #include <fstream>
+#include <sstream>
 
 template<typename Comment,
          template<typename ...> class Table,
@@ -126,8 +127,8 @@ BOOST_AUTO_TEST_CASE(test_example_with_comment_nocomment)
         BOOST_TEST(!has_comment_inside(serialized));
     }
     {
-        const auto data_nocomment = toml::parse("toml/tests/example.toml");
-        auto serialized = toml::parse("tmp1_com_nocomment.toml");
+        const auto data_nocomment = toml::parse<toml::discard_comments>("toml/tests/example.toml");
+        auto serialized = toml::parse<toml::discard_comments>("tmp1_com_nocomment.toml");
         {
             auto& owner = toml::find(serialized, "owner");
             auto& bio   = toml::find<std::string>(owner, "bio");
@@ -181,8 +182,8 @@ BOOST_AUTO_TEST_CASE(test_example_with_comment_map_dq_nocomment)
         BOOST_TEST(!has_comment_inside(serialized));
     }
     {
-        const auto data_nocomment = toml::parse("toml/tests/example.toml");
-        auto serialized = toml::parse("tmp1_com_map_dq_nocomment.toml");
+        const auto data_nocomment = toml::parse<toml::discard_comments>("toml/tests/example.toml");
+        auto serialized = toml::parse<toml::discard_comments>("tmp1_com_map_dq_nocomment.toml");
         {
             auto& owner = toml::find(serialized, "owner");
             auto& bio   = toml::find<std::string>(owner, "bio");
@@ -303,3 +304,60 @@ BOOST_AUTO_TEST_CASE(test_format_key)
         BOOST_TEST("\"special-chars-\\\\-\\\"-\\b-\\f-\\r-\\n-\\t\"" == toml::format_key(key));
     }
 }
+
+// In toml11, an implicitly-defined value does not have any comments.
+// So, in the following file,
+// ```toml
+// # comment
+// [[array-of-tables]]
+// foo = "bar"
+// ```
+// The array named "array-of-tables" does not have the comment, but the first
+// element of the array has. That means that, the above file is equivalent to
+// the following.
+// ```toml
+// array-of-tables = [
+//     # comment
+//     {foo = "bar"},
+// ]
+// ```
+// If the array itself has a comment (value_has_comment_ == true), we should try
+// to make it inline.
+// ```toml
+// # comment about array
+// array-of-tables = [
+//   # comment about table element
+//   {foo = "bar"}
+// ]
+// ```
+// If it is formatted as a multiline table, the two comments becomes
+// indistinguishable.
+// ```toml
+// # comment about array
+// # comment about table element
+// [[array-of-tables]]
+// foo = "bar"
+// ```
+// So we need to try to make it inline, and it force-inlines regardless
+// of the line width limit.
+//     It may fail if the element of a table has comment. In that case,
+// the array-of-tables will be formatted as a multiline table.
+BOOST_AUTO_TEST_CASE(test_distinguish_comment)
+{
+    const std::string str = R"(# comment about array itself
+array_of_table = [
+    # comment about the first element (table)
+    {key = "value"},
+])";
+    std::istringstream iss(str);
+    const auto data = toml::parse<toml::preserve_comments>(iss);
+    const auto serialized = toml::format(data, /*width = */ 0);
+
+    std::istringstream reparse(serialized);
+    const auto parsed = toml::parse<toml::preserve_comments>(reparse);
+
+    BOOST_TEST(parsed.at("array_of_table").comments().size()  == 1u);
+    BOOST_TEST(parsed.at("array_of_table").comments().front() == " comment about array itself");
+    BOOST_TEST(parsed.at("array_of_table").at(0).comments().size()  == 1u);
+    BOOST_TEST(parsed.at("array_of_table").at(0).comments().front() == " comment about the first element (table)");
+}

tests/test_string.cpp

@@ -133,7 +133,7 @@ BOOST_AUTO_TEST_CASE(test_string_add_assign)
         str += str2;
         BOOST_TEST(str.str == "foobar");
     }
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
     // std::string_view
     {
         toml::string str("foo");

tests/test_utility.cpp

@@ -9,27 +9,24 @@
 #include <vector>
 #include <array>
 
-BOOST_AUTO_TEST_CASE(test_resize)
+BOOST_AUTO_TEST_CASE(test_try_reserve)
 {
     {
-        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);
+        // 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);
     }
     {
         std::vector<int> v;
-        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);
+        toml::try_reserve(v, 100);
+        BOOST_TEST(v.capacity() == 100u);
     }
 }
 

tests/test_value.cpp

@@ -9,7 +9,7 @@
 #include <map>
 #include <list>
 
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 #include <string_view>
 #endif
 
@@ -423,7 +423,7 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_TEST(v2.as_boolean() == true);
     BOOST_TEST(v3.as_boolean() == true);
 
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
     std::string_view sv = "foo";
 
     toml::value v7(sv);

tests/test_visit.cpp

@@ -1,172 +0,0 @@
-#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);
-            }
-        }
-    }
-}

tests/test_windows.cpp

@@ -0,0 +1,12 @@
+#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;
+}

toml.hpp

@@ -25,17 +25,14 @@
 #ifndef TOML_FOR_MODERN_CPP
 #define TOML_FOR_MODERN_CPP
 
-#ifndef __cplusplus
-#    error "__cplusplus is not defined"
-#endif
-
-#if __cplusplus < 201103L && _MSC_VER < 1900
-#    error "toml11 requires C++11 or later."
-#endif
+#define TOML11_VERSION_MAJOR 3
+#define TOML11_VERSION_MINOR 7
+#define TOML11_VERSION_PATCH 1
 
 #include "toml/parser.hpp"
 #include "toml/literal.hpp"
 #include "toml/serializer.hpp"
 #include "toml/get.hpp"
+#include "toml/macros.hpp"
 
 #endif// TOML_FOR_MODERN_CPP

toml/color.hpp

@@ -1,7 +1,7 @@
 #ifndef TOML11_COLOR_HPP
 #define TOML11_COLOR_HPP
-#include <ostream>
 #include <cstdint>
+#include <ostream>
 
 #ifdef TOML11_COLORIZE_ERROR_MESSAGE
 #define TOML11_ERROR_MESSAGE_COLORIZED true

toml/combinator.hpp

@@ -2,18 +2,20 @@
 // Distributed under the MIT License.
 #ifndef TOML11_COMBINATOR_HPP
 #define TOML11_COMBINATOR_HPP
-#include "traits.hpp"
-#include "result.hpp"
-#include "utility.hpp"
-#include "region.hpp"
-#include <type_traits>
-#include <iterator>
-#include <limits>
-#include <array>
-#include <iomanip>
-#include <cstdio>
 #include <cassert>
 #include <cctype>
+#include <cstdio>
+
+#include <array>
+#include <iomanip>
+#include <iterator>
+#include <limits>
+#include <type_traits>
+
+#include "region.hpp"
+#include "result.hpp"
+#include "traits.hpp"
+#include "utility.hpp"
 
 // they scans characters and returns region if it matches to the condition.
 // when they fail, it does not change the location.
@@ -27,7 +29,7 @@ namespace detail
 // to output character as an error message.
 inline std::string show_char(const char c)
 {
-    // It supress an error that occurs only in Debug mode of MSVC++ on Windows.
+    // It suppresses an error that occurs only in Debug mode of MSVC++ on Windows.
     // I'm not completely sure but they check the value of char to be in the
     // range [0, 256) and some of the COMPLETELY VALID utf-8 character sometimes
     // has negative value (if char has sign). So here it re-interprets c as
@@ -56,13 +58,9 @@ struct character
 {
     static constexpr char target = C;
 
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& 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();
 
@@ -73,7 +71,7 @@ struct character
         }
         loc.advance(); // update location
 
-        return ok(region<Cont>(loc, first, loc.iter()));
+        return ok(region(loc, first, loc.iter()));
     }
 };
 template<char C>
@@ -89,13 +87,9 @@ struct in_range
     static constexpr char upper = Up;
     static constexpr char lower = Low;
 
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& 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();
 
@@ -106,7 +100,7 @@ struct in_range
         }
 
         loc.advance();
-        return ok(region<Cont>(loc, first, loc.iter()));
+        return ok(region(loc, first, loc.iter()));
     }
 };
 template<char L, char U> constexpr char in_range<L, U>::upper;
@@ -117,13 +111,9 @@ template<char L, char U> constexpr char in_range<L, U>::lower;
 template<typename Combinator>
 struct exclude
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& 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();
 
@@ -134,7 +124,7 @@ struct exclude
             return none();
         }
         loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but...
-        return ok(region<Cont>(loc, first, loc.iter()));
+        return ok(region(loc, first, loc.iter()));
     }
 };
 
@@ -142,19 +132,15 @@ struct exclude
 template<typename Combinator>
 struct maybe
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& 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<Cont>(loc));
+        return ok(region(loc));
     }
 };
 
@@ -164,15 +150,11 @@ struct sequence;
 template<typename Head, typename ... Tail>
 struct sequence<Head, Tail...>
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& 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);
+        auto rslt = Head::invoke(loc);
         if(rslt.is_err())
         {
             loc.reset(first);
@@ -182,9 +164,9 @@ struct sequence<Head, Tail...>
     }
 
     // called from the above function only, recursively.
-    template<typename Cont, typename Iterator>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
+    template<typename Iterator>
+    static result<region, none_t>
+    invoke(location& loc, region reg, Iterator first)
     {
         const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
@@ -201,9 +183,9 @@ template<typename Head>
 struct sequence<Head>
 {
     // would be called from sequence<T ...>::invoke only.
-    template<typename Cont, typename Iterator>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
+    template<typename Iterator>
+    static result<region, none_t>
+    invoke(location& loc, region reg, Iterator first)
     {
         const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
@@ -222,13 +204,9 @@ struct either;
 template<typename Head, typename ... Tail>
 struct either<Head, Tail...>
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& 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);
@@ -237,12 +215,9 @@ struct either<Head, Tail...>
 template<typename Head>
 struct either<Head>
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& loc)
     {
-        static_assert(std::is_same<char, typename Cont::value_type>::value,
-                      "internal error: container::value_type should be `char`.");
         return Head::invoke(loc);
     }
 };
@@ -257,11 +232,10 @@ struct unlimited{};
 template<typename T, std::size_t N>
 struct repeat<T, exactly<N>>
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& loc)
     {
-        region<Cont> retval(loc);
+        region retval(loc);
         const auto first = loc.iter();
         for(std::size_t i=0; i<N; ++i)
         {
@@ -280,11 +254,10 @@ struct repeat<T, exactly<N>>
 template<typename T, std::size_t N>
 struct repeat<T, at_least<N>>
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& loc)
     {
-        region<Cont> retval(loc);
+        region retval(loc);
 
         const auto first = loc.iter();
         for(std::size_t i=0; i<N; ++i)
@@ -312,11 +285,10 @@ struct repeat<T, at_least<N>>
 template<typename T>
 struct repeat<T, unlimited>
 {
-    template<typename Cont>
-    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc)
+    static result<region, none_t>
+    invoke(location& loc)
     {
-        region<Cont> retval(loc);
+        region retval(loc);
         while(true)
         {
             auto rslt = T::invoke(loc);

toml/comments.hpp

@@ -2,12 +2,19 @@
 // Distributed under the MIT License.
 #ifndef TOML11_COMMENTS_HPP
 #define TOML11_COMMENTS_HPP
+#include <initializer_list>
+#include <iterator>
+#include <stdexcept>
+#include <string>
 #include <type_traits>
 #include <utility>
-#include <iterator>
-#include <initializer_list>
 #include <vector>
-#include <string>
+
+#ifdef TOML11_PRESERVE_COMMENTS_BY_DEFAULT
+#  define TOML11_DEFAULT_COMMENT_STRATEGY ::toml::preserve_comments
+#else
+#  define TOML11_DEFAULT_COMMENT_STRATEGY ::toml::discard_comments
+#endif
 
 // 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,6 +88,54 @@ 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);
@@ -114,6 +169,7 @@ struct preserve_comments
     {
         return comments.erase(first, last);
     }
+#endif
 
     void swap(preserve_comments& other) {comments.swap(other.comments);}
 
@@ -290,7 +346,7 @@ operator+(const empty_iterator<T, C>& lhs, typename empty_iterator<T, C>::differ
 //
 // Why this is chose as the default type is because the last version (2.x.y)
 // does not contain any comments in a value. To minimize the impact on the
-// efficiency, this is choosed as a default.
+// efficiency, this is chosen as a default.
 //
 // To reduce the memory footprint, later we can try empty base optimization (EBO).
 struct discard_comments

toml/datetime.hpp

@@ -2,15 +2,16 @@
 // 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
 {
 
@@ -20,22 +21,7 @@ namespace toml
 namespace detail
 {
 // TODO: find more sophisticated way to handle this
-#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;
-    const auto result = ::localtime_r(src, &dst);
-    if (!result) { throw std::runtime_error("localtime_r failed."); }
-    return dst;
-}
-inline std::tm gmtime_s(const std::time_t* src)
-{
-    std::tm dst;
-    const auto result = ::gmtime_r(src, &dst);
-    if (!result) { throw std::runtime_error("gmtime_r failed."); }
-    return dst;
-}
-#elif _MSC_VER
+#if defined(_MSC_VER)
 inline std::tm localtime_s(const std::time_t* src)
 {
     std::tm dst;
@@ -50,6 +36,21 @@ inline std::tm gmtime_s(const std::time_t* src)
     if (result) { throw std::runtime_error("gmtime_s failed."); }
     return dst;
 }
+#elif (defined(_POSIX_C_SOURCE) && _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;
+    const auto result = ::localtime_r(src, &dst);
+    if (!result) { throw std::runtime_error("localtime_r failed."); }
+    return dst;
+}
+inline std::tm gmtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::gmtime_r(src, &dst);
+    if (!result) { throw std::runtime_error("gmtime_r failed."); }
+    return dst;
+}
 #else // fallback. not threadsafe
 inline std::tm localtime_s(const std::time_t* src)
 {

toml/exception.hpp

@@ -2,10 +2,11 @@
 // 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
 {
 

toml/from.hpp

@@ -2,7 +2,6 @@
 // Distributed under the MIT License.
 #ifndef TOML11_FROM_HPP
 #define TOML11_FROM_HPP
-#include "traits.hpp"
 
 namespace toml
 {

toml/get.hpp

@@ -2,10 +2,11 @@
 // 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
 {
@@ -139,7 +140,7 @@ get(basic_value<C, M, V>&& v)
 // ============================================================================
 // std::string_view
 
-#if __cplusplus >= 201703L
+#if defined(TOML11_USING_STRING_VIEW) && TOML11_USING_STRING_VIEW>0
 template<typename T, typename C,
          template<typename ...> class M, template<typename ...> class V>
 inline detail::enable_if_t<std::is_same<T, std::string_view>::value, std::string_view>
@@ -188,8 +189,7 @@ 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", {
-                    {std::addressof(detail::get_region(v)),
-                     concat_to_string("the actual type is ", v.type())}
+                    {v.location(), concat_to_string("the actual type is ", v.type())}
                 }), v.location());
         }
     }
@@ -198,24 +198,25 @@ get(const basic_value<C, M, V>& v)
 // ============================================================================
 // forward declaration to use this recursively. ignore this and go ahead.
 
-// array-like type with resize(N) method
+// array-like type with push_back(value) 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 container
-    detail::has_resize_method<T>, // T::resize(N) works
-    detail::negation<             // but not toml::array
+    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_exact_toml_type<T, basic_value<C, M, V>>>
     >::value, T>
 get(const basic_value<C, M, V>&);
 
-// array-like type with resize(N) method
+// array-like type without push_back(value) 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 container
-    detail::negation<detail::has_resize_method<T>>, // no T::resize() exists
-    detail::negation<                               // not toml::array
+    detail::is_container<T>,                           // T is a container
+    detail::negation<detail::has_push_back_method<T>>, // w/o push_back(...)
+    detail::negation<detail::has_specialized_from<T>>, // T does not have special conversion
+    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>&);
@@ -255,16 +256,19 @@ get(const basic_value<C, M, V>&);
 
 // toml::from<T>::from_toml(v)
 template<typename T, typename C,
-         template<typename ...> class M, template<typename ...> class V,
-         std::size_t S = sizeof(::toml::from<T>)>
-T get(const basic_value<C, M, V>&);
+         template<typename ...> class M, template<typename ...> class V>
+detail::enable_if_t<detail::has_specialized_from<T>::value, T>
+get(const basic_value<C, M, V>&);
 
-// T(const toml::value&) and T is not toml::basic_value
+// T(const toml::value&) and T is not toml::basic_value,
+// and it does not have `from<T>` nor `from_toml`.
 template<typename T, typename C,
          template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
     detail::negation<detail::is_basic_value<T>>,
-    std::is_constructible<T, const basic_value<C, M, V>&>
+    std::is_constructible<T, const basic_value<C, M, V>&>,
+    detail::negation<detail::has_from_toml_method<T, C, M, V>>,
+    detail::negation<detail::has_specialized_from<T>>
     >::value, T>
 get(const basic_value<C, M, V>&);
 
@@ -274,31 +278,55 @@ 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 container
-    detail::has_resize_method<T>, // T::resize(N) works
-    detail::negation<             // but not toml::array
+    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_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& ar = v.as_array();
+    const auto& ary = v.as_array();
+
     T container;
-    container.resize(ar.size());
-    std::transform(ar.cbegin(), ar.cend(), container.begin(),
-                   [](const value& x){return ::toml::get<value_type>(x);});
+    try_reserve(container, ary.size());
+
+    for(const auto& elem : ary)
+    {
+        container.push_back(get<value_type>(elem));
+    }
     return container;
 }
 
 // ============================================================================
-// array-like types; but does not have resize(); most likely std::array.
+// 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.
 
 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 container
-    detail::negation<detail::has_resize_method<T>>, // no T::resize() exists
-    detail::negation<                              // but not toml::array
+    detail::is_container<T>,                           // T is a container
+    detail::negation<detail::has_push_back_method<T>>, // w/o push_back
+    detail::negation<detail::has_specialized_from<T>>, // T does not have special conversion
+    detail::negation<                                  // T is not toml::array
         detail::is_exact_toml_type<T, basic_value<C, M, V>>>
     >::value, T>
 get(const basic_value<C, M, V>& v)
@@ -312,11 +340,13 @@ 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."), {
-                {std::addressof(detail::get_region(v)), "here"}
+                {v.location(), "here"}
             }));
     }
-    std::transform(ar.cbegin(), ar.cend(), container.begin(),
-                   [](const value& x){return ::toml::get<value_type>(x);});
+    for(std::size_t i=0; i<ar.size(); ++i)
+    {
+        container[i] = ::toml::get<value_type>(ar[i]);
+    }
     return container;
 }
 
@@ -336,9 +366,7 @@ 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."), {
-                {std::addressof(detail::get_region(v)), "here"}
-            }));
+            " elements in toml array."), {{v.location(), "here"}}));
     }
     return std::make_pair(::toml::get<first_type >(ar.at(0)),
                           ::toml::get<second_type>(ar.at(1)));
@@ -368,9 +396,7 @@ 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."), {
-                {std::addressof(detail::get_region(v)), "here"}
-            }));
+            " elements in toml array."), {{v.location(), "here"}}));
     }
     return detail::get_tuple_impl<T>(ar,
             detail::make_index_sequence<std::tuple_size<T>::value>{});
@@ -396,7 +422,7 @@ get(const basic_value<C, M, V>& v)
     T map;
     for(const auto& kv : v.as_table())
     {
-        map[key_type(kv.first)] = ::toml::get<mapped_type>(kv.second);
+        map.emplace(key_type(kv.first), get<mapped_type>(kv.second));
     }
     return map;
 }
@@ -419,9 +445,9 @@ get(const basic_value<C, M, V>& v)
     return ud;
 }
 template<typename T, typename C,
-         template<typename ...> class M, template<typename ...> class V,
-         std::size_t>
-T get(const basic_value<C, M, V>& v)
+         template<typename ...> class M, template<typename ...> class V>
+detail::enable_if_t<detail::has_specialized_from<T>::value, T>
+get(const basic_value<C, M, V>& v)
 {
     return ::toml::from<T>::from_toml(v);
 }
@@ -429,8 +455,10 @@ T get(const basic_value<C, M, V>& v)
 template<typename T, typename C,
          template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
-    detail::negation<detail::is_basic_value<T>>,
-    std::is_constructible<T, const basic_value<C, M, V>&>
+    detail::negation<detail::is_basic_value<T>>,                // T is not a toml::value
+    std::is_constructible<T, const basic_value<C, M, V>&>,      // T is constructible from toml::value
+    detail::negation<detail::has_from_toml_method<T, C, M, V>>, // and T does not have T.from_toml(v);
+    detail::negation<detail::has_specialized_from<T>>           // and T does not have toml::from<T>{};
     >::value, T>
 get(const basic_value<C, M, V>& v)
 {
@@ -449,10 +477,7 @@ 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)
     {
-        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
+        detail::throw_key_not_found_error(v, ky);
     }
     return tab.at(ky);
 }
@@ -463,10 +488,7 @@ 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)
     {
-        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
+        detail::throw_key_not_found_error(v, ky);
     }
     return tab.at(ky);
 }
@@ -477,10 +499,7 @@ 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)
     {
-        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
+        detail::throw_key_not_found_error(v, ky);
     }
     return basic_value<C, M, V>(std::move(tab.at(ky)));
 }
@@ -496,9 +515,7 @@ 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"), {
-                {std::addressof(detail::get_region(v)), "in this array"}
-            }));
+            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
     }
     return ary.at(idx);
 }
@@ -510,9 +527,7 @@ 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"), {
-                {std::addressof(detail::get_region(v)), "in this array"}
-            }));
+            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
     }
     return ary.at(idx);
 }
@@ -524,9 +539,7 @@ 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"), {
-                {std::addressof(detail::get_region(v)), "in this array"}
-            }));
+            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
     }
     return basic_value<C, M, V>(std::move(ary.at(idx)));
 }
@@ -542,10 +555,7 @@ find(const basic_value<C, M, V>& v, const key& ky)
     const auto& tab = v.as_table();
     if(tab.count(ky) == 0)
     {
-        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
+        detail::throw_key_not_found_error(v, ky);
     }
     return ::toml::get<T>(tab.at(ky));
 }
@@ -558,10 +568,7 @@ find(basic_value<C, M, V>& v, const key& ky)
     auto& tab = v.as_table();
     if(tab.count(ky) == 0)
     {
-        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
+        detail::throw_key_not_found_error(v, ky);
     }
     return ::toml::get<T>(tab.at(ky));
 }
@@ -574,10 +581,7 @@ 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)
     {
-        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
+        detail::throw_key_not_found_error(v, ky);
     }
     return ::toml::get<T>(std::move(tab.at(ky)));
 }
@@ -593,9 +597,7 @@ 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"), {
-                {std::addressof(detail::get_region(v)), "in this array"}
-            }));
+            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
     }
     return ::toml::get<T>(ary.at(idx));
 }
@@ -608,9 +610,7 @@ 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"), {
-                {std::addressof(detail::get_region(v)), "in this array"}
-            }));
+            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
     }
     return ::toml::get<T>(ary.at(idx));
 }
@@ -623,9 +623,7 @@ 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"), {
-                {std::addressof(detail::get_region(v)), "in this array"}
-            }));
+            "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
     }
     return ::toml::get<T>(std::move(ary.at(idx)));
 }
@@ -1042,6 +1040,50 @@ find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
     return get_or(tab.at(ky), std::forward<T>(opt));
 }
 
+// ---------------------------------------------------------------------------
+// recursive find-or with type deduction (find_or(value, keys, opt))
+
+template<typename Value, typename ... Ks,
+         typename detail::enable_if_t<(sizeof...(Ks) > 1), std::nullptr_t> = nullptr>
+         // here we need to add SFINAE in the template parameter to avoid
+         // infinite recursion in type deduction on gcc
+auto find_or(Value&& v, const toml::key& ky, Ks&& ... keys)
+    -> decltype(find_or(std::forward<Value>(v), ky, detail::last_one(std::forward<Ks>(keys)...)))
+{
+    if(!v.is_table())
+    {
+        return detail::last_one(std::forward<Ks>(keys)...);
+    }
+    auto&& tab = std::forward<Value>(v).as_table();
+    if(tab.count(ky) == 0)
+    {
+        return detail::last_one(std::forward<Ks>(keys)...);
+    }
+    return find_or(std::forward<decltype(tab)>(tab).at(ky), std::forward<Ks>(keys)...);
+}
+
+// ---------------------------------------------------------------------------
+// recursive find_or with explicit type specialization, find_or<int>(value, keys...)
+
+template<typename T, typename Value, typename ... Ks,
+         typename detail::enable_if_t<(sizeof...(Ks) > 1), std::nullptr_t> = nullptr>
+         // here we need to add SFINAE in the template parameter to avoid
+         // infinite recursion in type deduction on gcc
+auto find_or(Value&& v, const toml::key& ky, Ks&& ... keys)
+    -> decltype(find_or<T>(std::forward<Value>(v), ky, detail::last_one(std::forward<Ks>(keys)...)))
+{
+    if(!v.is_table())
+    {
+        return detail::last_one(std::forward<Ks>(keys)...);
+    }
+    auto&& tab = std::forward<Value>(v).as_table();
+    if(tab.count(ky) == 0)
+    {
+        return detail::last_one(std::forward<Ks>(keys)...);
+    }
+    return find_or(std::forward<decltype(tab)>(tab).at(ky), std::forward<Ks>(keys)...);
+}
+
 // ============================================================================
 // expect
 

toml/into.hpp

@@ -2,7 +2,6 @@
 // Distributed under the MIT License.
 #ifndef TOML11_INTO_HPP
 #define TOML11_INTO_HPP
-#include "traits.hpp"
 
 namespace toml
 {

toml/lexer.hpp

@@ -2,12 +2,13 @@
 // 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
@@ -69,15 +70,8 @@ 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,
@@ -125,17 +119,11 @@ 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>,
+using lex_basic_unescaped = exclude<either<in_range<0x00, 0x08>, // 0x09 (tab) is allowed
+                                           in_range<0x0A, 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>>>;
@@ -154,19 +142,47 @@ 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
+// split 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>>;
-#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
-using lex_ml_basic_unescaped    = exclude<either<in_range<0x00, 0x08>, // 0x09
-                                                 in_range<0x0a, 0x1F>, // is tab
-                                                 character<0x5C>,
-                                                 character<0x7F>,
+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>
+    >;
+
+using lex_ml_basic_unescaped    = exclude<either<in_range<0x00, 0x08>, // 0x09 is tab
+                                                 in_range<0x0A, 0x1F>,
+                                                 character<0x5C>, // backslash
+                                                 character<0x7F>, // DEL
                                                  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,
@@ -176,39 +192,39 @@ 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_delim,
+using lex_ml_basic_string = sequence<lex_ml_basic_string_open,
                                      lex_ml_basic_body,
-                                     lex_ml_basic_string_delim>;
+                                     lex_ml_basic_string_close>;
 
-using lex_literal_char = exclude<either<in_range<0x00, 0x08>,
-                                        in_range<0x10, 0x19>, character<0x27>>>;
+using lex_literal_char = exclude<either<in_range<0x00, 0x08>, in_range<0x0A, 0x1F>,
+                                        character<0x7F>, character<0x27>>>;
 using lex_apostrophe = character<'\''>;
 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>,
+                                           in_range<0x0A, 0x1F>,
                                            character<0x7F>,
                                            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_delim,
+using lex_ml_literal_string = sequence<lex_ml_literal_string_open,
                                        lex_ml_literal_body,
-                                       lex_ml_literal_string_delim>;
+                                       lex_ml_literal_string_close>;
 
 using lex_string = either<lex_ml_basic_string,   lex_basic_string,
                           lex_ml_literal_string, lex_literal_string>;
 
 // ===========================================================================
-
-using lex_comment_start_symbol = character<'#'>;
-using lex_non_eol = either<character<'\t'>, exclude<in_range<0x00, 0x19>>>;
-using lex_comment = sequence<lex_comment_start_symbol,
-                             repeat<lex_non_eol, unlimited>>;
-
 using lex_dot_sep = sequence<maybe<lex_ws>, character<'.'>, maybe<lex_ws>>;
 
 using lex_unquoted_key = repeat<either<lex_alpha, lex_digit,
@@ -243,6 +259,35 @@ using lex_array_table       = sequence<lex_array_table_open,
                                        maybe<lex_ws>,
                                        lex_array_table_close>;
 
+using lex_utf8_1byte = in_range<0x00, 0x7F>;
+using lex_utf8_2byte = sequence<
+        in_range<static_cast<char>(0xC2), static_cast<char>(0xDF)>,
+        in_range<static_cast<char>(0x80), static_cast<char>(0xBF)>
+    >;
+using lex_utf8_3byte = sequence<either<
+        sequence<character<static_cast<char>(0xE0)>,                          in_range<static_cast<char>(0xA0), static_cast<char>(0xBF)>>,
+        sequence<in_range <static_cast<char>(0xE1), static_cast<char>(0xEC)>, in_range<static_cast<char>(0x80), static_cast<char>(0xBF)>>,
+        sequence<character<static_cast<char>(0xED)>,                          in_range<static_cast<char>(0x80), static_cast<char>(0x9F)>>,
+        sequence<in_range <static_cast<char>(0xEE), static_cast<char>(0xEF)>, in_range<static_cast<char>(0x80), static_cast<char>(0xBF)>>
+    >, in_range<static_cast<char>(0x80), static_cast<char>(0xBF)>>;
+using lex_utf8_4byte = sequence<either<
+        sequence<character<static_cast<char>(0xF0)>,                          in_range<static_cast<char>(0x90), static_cast<char>(0xBF)>>,
+        sequence<in_range <static_cast<char>(0xF1), static_cast<char>(0xF3)>, in_range<static_cast<char>(0x80), static_cast<char>(0xBF)>>,
+        sequence<character<static_cast<char>(0xF4)>,                          in_range<static_cast<char>(0x80), static_cast<char>(0x8F)>>
+    >, in_range<static_cast<char>(0x80), static_cast<char>(0xBF)>,
+       in_range<static_cast<char>(0x80), static_cast<char>(0xBF)>>;
+using lex_utf8_code = either<
+        lex_utf8_1byte,
+        lex_utf8_2byte,
+        lex_utf8_3byte,
+        lex_utf8_4byte
+    >;
+
+using lex_comment_start_symbol = character<'#'>;
+using lex_non_eol_ascii = either<character<0x09>, in_range<0x20, 0x7E>>;
+using lex_comment = sequence<lex_comment_start_symbol, repeat<either<
+    lex_non_eol_ascii, lex_utf8_2byte, lex_utf8_3byte, lex_utf8_4byte>, unlimited>>;
+
 } // detail
 } // toml
 #endif // TOML_LEXER_HPP

toml/literal.hpp

@@ -11,12 +11,12 @@ inline namespace literals
 inline namespace toml_literals
 {
 
-inline ::toml::value operator"" _toml(const char* str, std::size_t len)
+// implementation
+inline ::toml::basic_value<TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>
+literal_internal_impl(::toml::detail::location loc)
 {
-    ::toml::detail::location<std::vector<char>>
-        loc(/* filename = */ std::string("TOML literal encoded in a C++ code"),
-            /* contents = */ std::vector<char>(str, str + len));
-
+    using value_type = ::toml::basic_value<
+        TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>;
     // 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>,
@@ -53,7 +53,7 @@ inline ::toml::value operator"" _toml(const char* str, std::size_t len)
     // If it is neither a table-key or a array-of-table-key, it may be a value.
     if(!is_table_key && !is_aots_key)
     {
-        if(auto data = ::toml::detail::parse_value<::toml::value>(loc))
+        if(auto data = ::toml::detail::parse_value<value_type>(loc))
         {
             return data.unwrap();
         }
@@ -70,17 +70,43 @@ inline ::toml::value operator"" _toml(const char* str, std::size_t len)
     // It is a valid toml file.
     // It should be parsed as if we parse a file with this content.
 
-    if(auto data = ::toml::detail::parse_toml_file<::toml::value>(loc))
+    if(auto data = ::toml::detail::parse_toml_file<value_type>(loc))
     {
         return data.unwrap();
     }
     else // none of them.
     {
-        throw ::toml::syntax_error(data.unwrap_err(),
-                                   source_location(std::addressof(loc)));
+        throw ::toml::syntax_error(data.unwrap_err(), source_location(loc));
     }
+
 }
 
+inline ::toml::basic_value<TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>
+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));
+    // literal length does not include the null character at the end.
+    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::basic_value<TOML11_DEFAULT_COMMENT_STRATEGY, std::unordered_map, std::vector>
+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

toml/macros.hpp

@@ -0,0 +1,121 @@
+#ifndef TOML11_MACROS_HPP
+#define TOML11_MACROS_HPP
+
+#define TOML11_STRINGIZE_AUX(x) #x
+#define TOML11_STRINGIZE(x)     TOML11_STRINGIZE_AUX(x)
+
+#define TOML11_CONCATENATE_AUX(x, y) x##y
+#define TOML11_CONCATENATE(x, y)     TOML11_CONCATENATE_AUX(x, y)
+
+// ============================================================================
+// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE
+
+#ifndef TOML11_WITHOUT_DEFINE_NON_INTRUSIVE
+
+// ----------------------------------------------------------------------------
+// TOML11_ARGS_SIZE
+
+#define TOML11_INDEX_RSEQ() \
+    32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, \
+    16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1, 0
+#define TOML11_ARGS_SIZE_IMPL(\
+    ARG1,  ARG2,  ARG3,  ARG4,  ARG5,  ARG6,  ARG7,  ARG8,  ARG9,  ARG10, \
+    ARG11, ARG12, ARG13, ARG14, ARG15, ARG16, ARG17, ARG18, ARG19, ARG20, \
+    ARG21, ARG22, ARG23, ARG24, ARG25, ARG26, ARG27, ARG28, ARG29, ARG30, \
+    ARG31, ARG32, N, ...) N
+#define TOML11_ARGS_SIZE_AUX(...) TOML11_ARGS_SIZE_IMPL(__VA_ARGS__)
+#define TOML11_ARGS_SIZE(...) TOML11_ARGS_SIZE_AUX(__VA_ARGS__, TOML11_INDEX_RSEQ())
+
+// ----------------------------------------------------------------------------
+// TOML11_FOR_EACH_VA_ARGS
+
+#define TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, ARG1     ) FUNCTOR(ARG1)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_32(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, __VA_ARGS__)
+
+#define TOML11_FOR_EACH_VA_ARGS(FUNCTOR, ...)\
+    TOML11_CONCATENATE(TOML11_FOR_EACH_VA_ARGS_AUX_, TOML11_ARGS_SIZE(__VA_ARGS__))(FUNCTOR, __VA_ARGS__)
+
+// ----------------------------------------------------------------------------
+// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE
+
+// use it in the following way.
+// ```cpp
+// namespace foo
+// {
+// struct Foo
+// {
+//     std::string s;
+//     double      d;
+//     int         i;
+// };
+// } // foo
+//
+// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i)
+// ```
+// And then you can use `toml::find<foo::Foo>(file, "foo");`
+//
+#define TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE(VAR_NAME)\
+    obj.VAR_NAME = toml::find<decltype(obj.VAR_NAME)>(v, TOML11_STRINGIZE(VAR_NAME));
+
+#define TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE(VAR_NAME)\
+    v[TOML11_STRINGIZE(VAR_NAME)] = obj.VAR_NAME;
+
+#define TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(NAME, ...)\
+    namespace toml {                                                                     \
+    template<>                                                                           \
+    struct from<NAME>                                                                    \
+    {                                                                                    \
+        template<typename C, template<typename ...> class T,                             \
+                 template<typename ...> class A>                                         \
+        static NAME from_toml(const basic_value<C, T, A>& v)                             \
+        {                                                                                \
+            NAME obj;                                                                    \
+            TOML11_FOR_EACH_VA_ARGS(TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE, __VA_ARGS__) \
+            return obj;                                                                  \
+        }                                                                                \
+    };                                                                                   \
+    template<>                                                                           \
+    struct into<NAME>                                                                    \
+    {                                                                                    \
+        static value into_toml(const NAME& obj)                                          \
+        {                                                                                \
+            ::toml::value v = ::toml::table{};                                           \
+            TOML11_FOR_EACH_VA_ARGS(TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE, __VA_ARGS__) \
+            return v;                                                                    \
+        }                                                                                \
+    };                                                                                   \
+    } /* toml */
+
+#endif// TOML11_WITHOUT_DEFINE_NON_INTRUSIVE
+
+#endif// TOML11_MACROS_HPP

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,22 +67,21 @@ 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 Container::const_iterator;
+    using const_iterator  = typename std::vector<char>::const_iterator;
     using difference_type = typename const_iterator::difference_type;
-    using source_ptr      = std::shared_ptr<const Container>;
+    using source_ptr      = std::shared_ptr<const std::vector<char>>;
 
-    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(std::string source_name, std::vector<char> cont)
+      : source_(std::make_shared<std::vector<char>>(std::move(cont))),
+        line_number_(1), source_name_(std::move(source_name)), iter_(source_->cbegin())
     {}
+    location(std::string source_name, const std::string& cont)
+      : source_(std::make_shared<std::vector<char>>(cont.begin(), cont.end())),
+        line_number_(1), source_name_(std::move(source_name)), iter_(source_->cbegin())
+    {}
+
     location(const location&) = default;
     location(location&&)      = default;
     location& operator=(const location&) = default;
@@ -195,33 +194,27 @@ 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 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");
+    using const_iterator = typename std::vector<char>::const_iterator;
+    using source_ptr     = std::shared_ptr<const std::vector<char>>;
 
     // delete default constructor. source_ never be null.
     region() = delete;
 
-    region(const location<Container>& loc)
+    explicit region(const location& loc)
       : source_(loc.source()), source_name_(loc.name()),
         first_(loc.iter()), last_(loc.iter())
     {}
-    region(location<Container>&& loc)
+    explicit region(location&& loc)
       : source_(loc.source()), source_name_(loc.name()),
         first_(loc.iter()), last_(loc.iter())
     {}
 
-    region(const location<Container>& loc, const_iterator f, const_iterator l)
+    region(const location& loc, const_iterator f, const_iterator l)
       : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l)
     {}
-    region(location<Container>&& loc, const_iterator f, const_iterator l)
+    region(location&& loc, const_iterator f, const_iterator l)
       : source_(loc.source()), source_name_(loc.name()), first_(f), last_(l)
     {}
 
@@ -350,9 +343,9 @@ struct region final : public region_base
                             }))
                     {
                         // unwrap the first '#' by std::next.
-                        auto str = make_string(std::next(comment_found), iter);
-                        if(str.back() == '\r') {str.pop_back();}
-                        com.push_back(std::move(str));
+                        auto s = make_string(std::next(comment_found), iter);
+                        if(!s.empty() && s.back() == '\r') {s.pop_back();}
+                        com.push_back(std::move(s));
                     }
                     else
                     {
@@ -403,9 +396,9 @@ struct region final : public region_base
                     }))
                 {
                     // unwrap the first '#' by std::next.
-                    auto str = make_string(std::next(comment_found), this->line_end());
-                    if(str.back() == '\r') {str.pop_back();}
-                    com.push_back(std::move(str));
+                    auto s = make_string(std::next(comment_found), this->line_end());
+                    if(!s.empty() && s.back() == '\r') {s.pop_back();}
+                    com.push_back(std::move(s));
                 }
             }
         }
@@ -419,107 +412,6 @@ 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

toml/serializer.hpp

@@ -2,12 +2,14 @@
 // Distributed under the MIT License.
 #ifndef TOML11_SERIALIZER_HPP
 #define TOML11_SERIALIZER_HPP
-#include "value.hpp"
-#include "lexer.hpp"
-#include "visit.hpp"
-#include <limits>
+#include <cmath>
 #include <cstdio>
 
+#include <limits>
+
+#include "lexer.hpp"
+#include "value.hpp"
+
 namespace toml
 {
 
@@ -23,39 +25,70 @@ 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.
-inline std::string format_key(const toml::key& key)
+template<typename charT, typename traits, typename Alloc>
+std::basic_string<charT, traits, Alloc>
+format_key(const std::basic_string<charT, traits, Alloc>& k)
 {
-    detail::location<toml::key> loc(key, key);
+    if(k.empty())
+    {
+        return std::string("\"\"");
+    }
+
+    // check the key can be a bare (unquoted) key
+    detail::location loc(k, std::vector<char>(k.begin(), k.end()));
     detail::lex_unquoted_key::invoke(loc);
     if(loc.iter() == loc.end())
     {
-        return key; // all the tokens are consumed. the key is unquoted-key.
+        return k; // all the tokens are consumed. the key is unquoted-key.
     }
-    std::string token("\"");
-    for(const char c : key)
+
+    //if it includes special characters, then format it in a "quoted" key.
+    std::basic_string<charT, traits, Alloc> serialized("\"");
+    for(const char c : k)
     {
         switch(c)
         {
-            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;}
+            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;}
         }
     }
-    token += "\"";
-    return token;
+    serialized += "\"";
+    return serialized;
 }
 
-template<typename Comment,
-         template<typename ...> class Table,
-         template<typename ...> class Array>
+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)
+{
+    if(keys.empty())
+    {
+        return std::string("\"\"");
+    }
+
+    std::basic_string<charT, traits, Alloc> serialized;
+    for(const auto& ky : keys)
+    {
+        serialized += format_key(ky);
+        serialized += charT('.');
+    }
+    serialized.pop_back(); // remove the last dot '.'
+    return serialized;
+}
+
+template<typename Value>
 struct serializer
 {
-    using value_type           = basic_value<Comment, Table, Array>;
+    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 key_type             = typename value_type::key_type            ;
     using comment_type         = typename value_type::comment_type        ;
     using boolean_type         = typename value_type::boolean_type        ;
@@ -73,8 +106,10 @@ struct serializer
                const int         float_prec     = std::numeric_limits<toml::floating>::max_digits10,
                const bool        can_be_inlined = false,
                const bool        no_comment     = false,
-               std::vector<toml::key> ks        = {})
+               std::vector<toml::key> ks        = {},
+               const bool     value_has_comment = false)
         : can_be_inlined_(can_be_inlined), no_comment_(no_comment),
+          value_has_comment_(value_has_comment && !no_comment),
           float_prec_(float_prec), width_(w), keys_(std::move(ks))
     {}
     ~serializer() = default;
@@ -89,6 +124,29 @@ struct serializer
     }
     std::string operator()(const floating_type f) const
     {
+        if(std::isnan(f))
+        {
+            if(std::signbit(f))
+            {
+                return std::string("-nan");
+            }
+            else
+            {
+                return std::string("nan");
+            }
+        }
+        else if(!std::isfinite(f))
+        {
+            if(std::signbit(f))
+            {
+                return std::string("-inf");
+            }
+            else
+            {
+                return std::string("inf");
+            }
+        }
+
         const auto fmt = "%.*g";
         const auto bsz = std::snprintf(nullptr, 0, fmt, this->float_prec_, f);
         // +1 for null character(\0)
@@ -96,7 +154,7 @@ struct serializer
         std::snprintf(buf.data(), buf.size(), fmt, this->float_prec_, f);
 
         std::string token(buf.begin(), std::prev(buf.end()));
-        if(token.back() == '.') // 1. => 1.0
+        if(!token.empty() && token.back() == '.') // 1. => 1.0
         {
             token += '0';
         }
@@ -113,35 +171,6 @@ 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;
     }
@@ -149,12 +178,24 @@ struct serializer
     {
         if(s.kind == string_t::basic)
         {
-            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend())
+            if((std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() ||
+                std::find(s.str.cbegin(), s.str.cend(), '\"') != s.str.cend()) &&
+               this->width_ != (std::numeric_limits<std::size_t>::max)())
             {
-                // 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;
+                // 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;
             }
 
             // no linefeed. try to make it oneline-string.
@@ -195,7 +236,11 @@ 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() )
             {
-                const std::string open("'''\n");
+                std::string open("'''");
+                if(this->width_ + 6 < s.str.size())
+                {
+                    open += '\n'; // the first newline is ignored by TOML spec
+                }
                 const std::string close("'''");
                 return open + s.str + close;
             }
@@ -234,92 +279,18 @@ struct serializer
 
     std::string operator()(const array_type& v) const
     {
-        if(!v.empty() && v.front().is_table())// v is an array of tables
-        {
-            // if it's not inlined, we need to add `[[table.key]]`.
-            // but if it can be inlined,
-            // ```
-            // table.key = [
-            //   {...},
-            //   # comment
-            //   {...},
-            // ]
-            // ```
-            if(this->can_be_inlined_)
-            {
-                std::string token;
-                if(!keys_.empty())
-                {
-                    token += this->serialize_key(keys_.back());
-                    token += " = ";
-                }
-                bool failed = false;
-                token += "[\n";
-                for(const auto& item : v)
-                {
-                    // if an element of the table has a comment, the table
-                    // cannot be inlined.
-                    if(this->has_comment_inside(item.as_table()))
-                    {
-                        failed = true;
-                        break;
-                    }
-                    if(!no_comment_)
-                    {
-                        for(const auto& c : item.comments())
-                        {
-                            token += '#';
-                            token += c;
-                            token += '\n';
-                        }
-                    }
-
-                    const auto t = this->make_inline_table(item.as_table());
-
-                    if(t.size() + 1 > width_ || // +1 for the last comma {...},
-                       std::find(t.cbegin(), t.cend(), '\n') != t.cend())
-                    {
-                        failed = true;
-                        break;
-                    }
-                    token += t;
-                    token += ",\n";
-                }
-                if(!failed)
-                {
-                    token += "]\n";
-                    return token;
-                }
-                // if failed, serialize them as [[array.of.tables]].
-            }
-
-            std::string token;
-            for(const auto& item : v)
-            {
-                if(!no_comment_)
-                {
-                    for(const auto& c : item.comments())
-                    {
-                        token += '#';
-                        token += c;
-                        token += '\n';
-                    }
-                }
-                token += "[[";
-                token += this->serialize_dotted_key(keys_);
-                token += "]]\n";
-                token += this->make_multiline_table(item.as_table());
-            }
-            return token;
-        }
         if(v.empty())
         {
             return std::string("[]");
         }
+        if(this->is_array_of_tables(v))
+        {
+            return make_array_of_tables(v);
+        }
 
         // not an array of tables. normal array.
         // first, try to make it inline if none of the elements have a comment.
-        if(!this->has_comment_inside(v))
+        if( ! this->has_comment_inside(v))
         {
             const auto inl = this->make_inline_array(v);
             if(inl.size() < this->width_ &&
@@ -340,7 +311,7 @@ struct serializer
         token += "[\n";
         for(const auto& item : v)
         {
-            if(!item.comments().empty() && !no_comment_)
+            if( ! item.comments().empty() && !no_comment_)
             {
                 // if comment exists, the element must be the only element in the line.
                 // e.g. the following is not allowed.
@@ -366,15 +337,25 @@ struct serializer
                     token += '\n';
                 }
                 token += toml::visit(*this, item);
-                if(token.back() == '\n') {token.pop_back();}
+                if(!token.empty() && token.back() == '\n') {token.pop_back();}
                 token += ",\n";
                 continue;
             }
             std::string next_elem;
-            next_elem += toml::visit(*this, item);
+            if(item.is_table())
+            {
+                serializer ser(*this);
+                ser.can_be_inlined_ = true;
+                ser.width_ = (std::numeric_limits<std::size_t>::max)();
+                next_elem += toml::visit(ser, item);
+            }
+            else
+            {
+                next_elem += toml::visit(*this, item);
+            }
 
             // comma before newline.
-            if(next_elem.back() == '\n') {next_elem.pop_back();}
+            if(!next_elem.empty() && next_elem.back() == '\n') {next_elem.pop_back();}
 
             // if current line does not exceeds the width limit, continue.
             if(current_line.size() + next_elem.size() + 1 < this->width_)
@@ -401,7 +382,10 @@ struct serializer
         }
         if(!current_line.empty())
         {
-            if(current_line.back() != '\n') {current_line += '\n';}
+            if(!current_line.empty() && current_line.back() != '\n')
+            {
+                current_line += '\n';
+            }
             token += current_line;
         }
         token += "]\n";
@@ -418,7 +402,7 @@ struct serializer
             std::string token;
             if(!this->keys_.empty())
             {
-                token += this->serialize_key(this->keys_.back());
+                token += format_key(this->keys_.back());
                 token += " = ";
             }
             token += this->make_inline_table(v);
@@ -433,7 +417,7 @@ struct serializer
         if(!keys_.empty())
         {
             token += '[';
-            token += this->serialize_dotted_key(keys_);
+            token += format_keys(keys_);
             token += "]\n";
         }
         token += this->make_multiline_table(v);
@@ -442,25 +426,6 @@ 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.
@@ -476,7 +441,19 @@ struct serializer
                 case '\f': {retval += "\\f";  break;}
                 case '\n': {retval += "\\n";  break;}
                 case '\r': {retval += "\\r";  break;}
-                default  : {retval += c;      break;}
+                default  :
+                {
+                    if((0x00 <= c && c <= 0x08) || (0x0A <= c && c <= 0x1F) || c == 0x7F)
+                    {
+                        retval += "\\u00";
+                        retval += char(48 + (c / 16));
+                        retval += char((c % 16 < 10 ? 48 : 55) + (c % 16));
+                    }
+                    else
+                    {
+                        retval += c;
+                    }
+                }
             }
         }
         return retval;
@@ -490,7 +467,9 @@ struct serializer
             switch(*i)
             {
                 case '\\': {retval += "\\\\"; break;}
-                case '\"': {retval += "\\\""; break;}
+                // One or two consecutive "s are allowed.
+                // Later we will check there are no three consecutive "s.
+                //   case '\"': {retval += "\\\""; break;}
                 case '\b': {retval += "\\b";  break;}
                 case '\t': {retval += "\\t";  break;}
                 case '\f': {retval += "\\f";  break;}
@@ -508,9 +487,40 @@ struct serializer
                     }
                     break;
                 }
-                default: {retval += *i; break;}
+                default  :
+                {
+                    const auto c = *i;
+                    if((0x00 <= c && c <= 0x08) || (0x0A <= c && c <= 0x1F) || c == 0x7F)
+                    {
+                        retval += "\\u00";
+                        retval += char(48 + (c / 16));
+                        retval += char((c % 16 < 10 ? 48 : 55) + (c % 16));
+                    }
+                    else
+                    {
+                        retval += c;
+                    }
+                }
+
             }
         }
+        // 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;
     }
 
@@ -547,8 +557,10 @@ 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(),
-                                      this->float_prec_, true), item);
+            token += visit(serializer(
+                (std::numeric_limits<std::size_t>::max)(), this->float_prec_,
+                /* inlined */ true, /*no comment*/ false, /*keys*/ {},
+                /*has_comment*/ !item.comments().empty()), item);
         }
         token += ']';
         return token;
@@ -565,10 +577,12 @@ struct serializer
         {
             // in inline tables, trailing comma is not allowed (toml-lang #569).
             if(is_first) {is_first = false;} else {token += ',';}
-            token += this->serialize_key(kv.first);
+            token += format_key(kv.first);
             token += '=';
-            token += visit(serializer(std::numeric_limits<std::size_t>::max(),
-                                      this->float_prec_, true), kv.second);
+            token += visit(serializer(
+                (std::numeric_limits<std::size_t>::max)(), this->float_prec_,
+                /* inlined */ true, /*no comment*/ false, /*keys*/ {},
+                /*has_comment*/ !kv.second.comments().empty()), kv.second);
         }
         token += '}';
         return token;
@@ -578,30 +592,33 @@ struct serializer
     {
         std::string token;
 
-        // print non-table stuff first. because after printing [foo.bar], the
-        // remaining non-table values will be assigned into [foo.bar], not [foo]
-        for(const auto kv : v)
+        // print non-table elements first.
+        // ```toml
+        // [foo]         # a table we're writing now here
+        // key = "value" # <- non-table element, "key"
+        // # ...
+        // [foo.bar] # <- table element, "bar"
+        // ```
+        // because after printing [foo.bar], the remaining non-table values will
+        // be assigned into [foo.bar], not [foo]. Those values should be printed
+        // earlier.
+        for(const auto& kv : v)
         {
             if(kv.second.is_table() || is_array_of_tables(kv.second))
             {
                 continue;
             }
 
-            if(!kv.second.comments().empty() && !no_comment_)
-            {
-                for(const auto& c : kv.second.comments())
-                {
-                    token += '#';
-                    token += c;
-                    token += '\n';
-                }
-            }
-            const auto key_and_sep    = this->serialize_key(kv.first) + " = ";
+            token += write_comments(kv.second);
+
+            const auto key_and_sep    = format_key(kv.first) + " = ";
             const auto residual_width = (this->width_ > key_and_sep.size()) ?
                                         this->width_ - key_and_sep.size() : 0;
             token += key_and_sep;
-            token += visit(serializer(residual_width, this->float_prec_, true),
-                           kv.second);
+            token += visit(serializer(residual_width, this->float_prec_,
+                /*can be inlined*/ true, /*no comment*/ false, /*keys*/ {},
+                /*has_comment*/ !kv.second.comments().empty()), kv.second);
+
             if(token.back() != '\n')
             {
                 token += '\n';
@@ -627,45 +644,172 @@ struct serializer
             ks.push_back(kv.first);
 
             auto tmp = visit(serializer(this->width_, this->float_prec_,
-                !multiline_table_printed, this->no_comment_, ks),
-                kv.second);
+                !multiline_table_printed, this->no_comment_, ks,
+                /*has_comment*/ !kv.second.comments().empty()), kv.second);
 
+            // If it is the first time to print a multi-line table, it would be
+            // helpful to separate normal key-value pair and subtables by a
+            // newline.
+            // (this checks if the current key-value pair contains newlines.
+            //  but it is not perfect because multi-line string can also contain
+            //  a newline. in such a case, an empty line will be written) TODO
             if((!multiline_table_printed) &&
                std::find(tmp.cbegin(), tmp.cend(), '\n') != tmp.cend())
             {
                 multiline_table_printed = true;
-            }
-            else
-            {
-                // still inline tables only.
-                tmp += '\n';
-            }
+                token += '\n'; // separate key-value pairs and subtables
 
-            if(!kv.second.comments().empty() && !no_comment_)
-            {
-                for(const auto& c : kv.second.comments())
+                token += write_comments(kv.second);
+                token += tmp;
+
+                // care about recursive tables (all tables in each level prints
+                // newline and there will be a full of newlines)
+                if(tmp.substr(tmp.size() - 2, 2) != "\n\n" &&
+                   tmp.substr(tmp.size() - 4, 4) != "\r\n\r\n" )
                 {
-                    token += '#';
-                    token += c;
                     token += '\n';
                 }
             }
-            token += tmp;
+            else
+            {
+                token += write_comments(kv.second);
+                token += tmp;
+                token += '\n';
+            }
         }
         return token;
     }
 
+    std::string make_array_of_tables(const array_type& v) const
+    {
+        // if it's not inlined, we need to add `[[table.key]]`.
+        // but if it can be inlined, we can format it as the following.
+        // ```
+        // table.key = [
+        //   {...},
+        //   # comment
+        //   {...},
+        // ]
+        // ```
+        // This function checks if inlinization is possible or not, and then
+        // format the array-of-tables in a proper way.
+        //
+        // Note about comments:
+        //
+        // If the array itself has a comment (value_has_comment_ == true), we
+        // should try to make it inline.
+        // ```toml
+        // # comment about array
+        // array = [
+        //   # comment about table element
+        //   {of = "table"}
+        // ]
+        // ```
+        // If it is formatted as a multiline table, the two comments becomes
+        // indistinguishable.
+        // ```toml
+        // # comment about array
+        // # comment about table element
+        // [[array]]
+        // of = "table"
+        // ```
+        // So we need to try to make it inline, and it force-inlines regardless
+        // of the line width limit.
+        //     It may fail if the element of a table has comment. In that case,
+        // the array-of-tables will be formatted as a multiline table.
+        if(this->can_be_inlined_ || this->value_has_comment_)
+        {
+            std::string token;
+            if(!keys_.empty())
+            {
+                token += format_key(keys_.back());
+                token += " = ";
+            }
+
+            bool failed = false;
+            token += "[\n";
+            for(const auto& item : v)
+            {
+                // if an element of the table has a comment, the table
+                // cannot be inlined.
+                if(this->has_comment_inside(item.as_table()))
+                {
+                    failed = true;
+                    break;
+                }
+                // write comments for the table itself
+                token += write_comments(item);
+
+                const auto t = this->make_inline_table(item.as_table());
+
+                if(t.size() + 1 > width_ || // +1 for the last comma {...},
+                   std::find(t.cbegin(), t.cend(), '\n') != t.cend())
+                {
+                    // if the value itself has a comment, ignore the line width limit
+                    if( ! this->value_has_comment_)
+                    {
+                        failed = true;
+                        break;
+                    }
+                }
+                token += t;
+                token += ",\n";
+            }
+
+            if( ! failed)
+            {
+                token += "]\n";
+                return token;
+            }
+            // if failed, serialize them as [[array.of.tables]].
+        }
+
+        std::string token;
+        for(const auto& item : v)
+        {
+            token += write_comments(item);
+            token += "[[";
+            token += format_keys(keys_);
+            token += "]]\n";
+            token += this->make_multiline_table(item.as_table());
+        }
+        return token;
+    }
+
+    std::string write_comments(const value_type& v) const
+    {
+        std::string retval;
+        if(this->no_comment_) {return retval;}
+
+        for(const auto& c : v.comments())
+        {
+            retval += '#';
+            retval += c;
+            retval += '\n';
+        }
+        return retval;
+    }
+
     bool is_array_of_tables(const value_type& v) const
     {
-        if(!v.is_array()) {return false;}
-        const auto& a = v.as_array();
-        return !a.empty() && a.front().is_table();
+        if(!v.is_array() || v.as_array().empty()) {return false;}
+        return is_array_of_tables(v.as_array());
+    }
+    bool is_array_of_tables(const array_type& v) const
+    {
+        // Since TOML v0.5.0, heterogeneous arrays are allowed. So we need to
+        // check all the element in an array to check if the array is an array
+        // of tables.
+        return std::all_of(v.begin(), v.end(), [](const value_type& elem) {
+                return elem.is_table();
+            });
     }
 
   private:
 
     bool        can_be_inlined_;
     bool        no_comment_;
+    bool        value_has_comment_;
     int         float_prec_;
     std::size_t width_;
     std::vector<toml::key> keys_;
@@ -678,6 +822,7 @@ 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())
@@ -688,10 +833,11 @@ 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
         }
-        oss << visit(serializer<C, M, V>(w, fprec, no_comment, false), v);
+        const auto serialized = visit(serializer<value_type>(w, fprec, false, no_comment), v);
+        oss << serialized;
         return oss.str();
     }
-    return visit(serializer<C, M, V>(w, fprec, force_inline), v);
+    return visit(serializer<value_type>(w, fprec, force_inline), v);
 }
 
 namespace detail
@@ -708,7 +854,7 @@ template<typename charT, typename traits>
 std::basic_ostream<charT, traits>&
 nocomment(std::basic_ostream<charT, traits>& os)
 {
-    // by default, it is zero. and by defalut, it shows comments.
+    // by default, it is zero. and by default, it shows comments.
     os.iword(detail::comment_index(os)) = 1;
     return os;
 }
@@ -717,7 +863,7 @@ template<typename charT, typename traits>
 std::basic_ostream<charT, traits>&
 showcomment(std::basic_ostream<charT, traits>& os)
 {
-    // by default, it is zero. and by defalut, it shows comments.
+    // by default, it is zero. and by default, it shows comments.
     os.iword(detail::comment_index(os)) = 0;
     return os;
 }
@@ -727,12 +873,14 @@ 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());
     os.width(0);
 
-    // by defualt, iword is initialized byl 0. And by default, toml11 outputs
+    // by default, iword is initialized by 0. And by default, toml11 outputs
     // comments. So `0` means showcomment. 1 means nocommnet.
     const bool no_comment = (1 == os.iword(detail::comment_index(os)));
 
@@ -742,7 +890,8 @@ 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`.
-    os << visit(serializer<C, M, V>(w, fprec, false, no_comment), v);
+    const auto serialized = visit(serializer<value_type>(w, fprec, no_comment, false), v);
+    os << serialized;
 
     // if v is a non-table value, and has only one comment, then
     // put a comment just after a value. in the following way.

toml/source_location.hpp

@@ -2,8 +2,10 @@
 // Distributed under the MIT License.
 #ifndef TOML11_SOURCE_LOCATION_HPP
 #define TOML11_SOURCE_LOCATION_HPP
-#include "region.hpp"
 #include <cstdint>
+#include <sstream>
+
+#include "region.hpp"
 
 namespace toml
 {
@@ -38,12 +40,12 @@ struct source_location
   public:
 
     source_location()
-        : line_num_(0), column_num_(0), region_size_(0),
+        : line_num_(1), column_num_(1), region_size_(1),
           file_name_("unknown file"), line_str_("")
     {}
 
     explicit source_location(const detail::region_base* reg)
-        : line_num_(0), column_num_(0), region_size_(0),
+        : line_num_(1), column_num_(1), region_size_(1),
           file_name_("unknown file"), line_str_("")
     {
         if(reg)
@@ -60,6 +62,21 @@ 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;
@@ -82,5 +99,135 @@ 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

toml/string.hpp

@@ -2,11 +2,17 @@
 // Distributed under the MIT License.
 #ifndef TOML11_STRING_HPP
 #define TOML11_STRING_HPP
+
+#include "version.hpp"
+
+#include <cstdint>
+
 #include <algorithm>
 #include <string>
-#include <cstdint>
-#if __cplusplus >= 201703L
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 #if __has_include(<string_view>)
+#define TOML11_USING_STRING_VIEW 1
 #include <string_view>
 #endif
 #endif
@@ -51,7 +57,7 @@ struct string
     string& operator+=(const std::string& rhs) {str += rhs; return *this;}
     string& operator+=(const string&      rhs) {str += rhs.str; return *this;}
 
-#if __cplusplus >= 201703L
+#if defined(TOML11_USING_STRING_VIEW) && TOML11_USING_STRING_VIEW>0
     explicit string(std::string_view s): kind(string_t::basic), str(s){}
     string(std::string_view s, string_t k): kind(k), str(s){}
 

toml/traits.hpp

@@ -2,12 +2,19 @@
 // Distributed under the MIT License.
 #ifndef TOML11_TRAITS_HPP
 #define TOML11_TRAITS_HPP
+
+#include "from.hpp"
+#include "into.hpp"
+#include "version.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 TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 #if __has_include(<string_view>)
 #include <string_view>
 #endif // has_include(<string_view>)
@@ -43,17 +50,23 @@ 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_resize_method_impl
+struct has_reserve_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
@@ -76,6 +89,22 @@ struct has_into_toml_method_impl
     static std::false_type check(...);
 };
 
+struct has_specialized_from_impl
+{
+    template<typename T>
+    static std::false_type check(...);
+    template<typename T, std::size_t S = sizeof(::toml::from<T>)>
+    static std::true_type check(::toml::from<T>*);
+};
+struct has_specialized_into_impl
+{
+    template<typename T>
+    static std::false_type check(...);
+    template<typename T, std::size_t S = sizeof(::toml::into<T>)>
+    static std::true_type check(::toml::from<T>*);
+};
+
+
 /// Intel C++ compiler can not use decltype in parent class declaration, here
 /// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076
 #ifdef __INTEL_COMPILER
@@ -91,7 +120,9 @@ 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_resize_method : decltype(has_resize_method_impl::check<T>(nullptr)){};
+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)){};
 template<typename T>
 struct is_comparable : decltype(is_comparable_impl::check<T>(nullptr)){};
 
@@ -104,6 +135,11 @@ template<typename T>
 struct has_into_toml_method
 : decltype(has_into_toml_method_impl::check<T>(nullptr)){};
 
+template<typename T>
+struct has_specialized_from : decltype(has_specialized_from_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_specialized_into : decltype(has_specialized_into_impl::check<T>(nullptr)){};
+
 #ifdef __INTEL_COMPILER
 #undef decltype
 #endif
@@ -111,7 +147,7 @@ struct has_into_toml_method
 // ---------------------------------------------------------------------------
 // C++17 and/or/not
 
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
 
 using std::conjunction;
 using std::disjunction;
@@ -149,6 +185,10 @@ 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{};
@@ -169,8 +209,10 @@ template<typename T>
 struct is_container : conjunction<
     negation<is_map<T>>,                         // not a map
     negation<std::is_same<T, std::string>>,      // not a std::string
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
+#if __has_include(<string_view>)
     negation<std::is_same<T, std::string_view>>, // not a std::string_view
+#endif // has_include(<string_view>)
 #endif
     has_iterator<T>,                             // has T::iterator
     has_value_type<T>                            // has T::value_type
@@ -192,7 +234,7 @@ struct is_basic_value<::toml::basic_value<C, M, V>>: std::true_type{};
 // ---------------------------------------------------------------------------
 // C++14 index_sequence
 
-#if __cplusplus >= 201402L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201402L
 
 using std::index_sequence;
 using std::make_index_sequence;
@@ -222,12 +264,12 @@ struct index_sequence_maker<0>
 template<std::size_t N>
 using make_index_sequence = typename index_sequence_maker<N-1>::type;
 
-#endif // __cplusplus >= 2014
+#endif // cplusplus >= 2014
 
 // ---------------------------------------------------------------------------
 // C++14 enable_if_t
 
-#if __cplusplus >= 201402L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201402L
 
 using std::enable_if_t;
 
@@ -236,12 +278,12 @@ using std::enable_if_t;
 template<bool B, typename T>
 using enable_if_t = typename std::enable_if<B, T>::type;
 
-#endif // __cplusplus >= 2014
+#endif // cplusplus >= 2014
 
 // ---------------------------------------------------------------------------
 // return_type_of_t
 
-#if __cplusplus >= 201703L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L && defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable>=201703
 
 template<typename F, typename ... Args>
 using return_type_of_t = std::invoke_result_t<F, Args...>;

toml/types.hpp

@@ -2,12 +2,13 @@
 // 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
 {
@@ -20,9 +21,14 @@ class basic_value;
 using character = char;
 using key = std::string;
 
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ <= 4
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 using boolean        = bool;
 using integer        = std::int64_t;
-using floating       = double; // "float" is a keyward, cannot use it here.
+using floating       = double; // "float" is a keyword, cannot use it here.
 // the following stuffs are structs defined here, so aliases are not needed.
 // - string
 // - offset_datetime
@@ -31,12 +37,26 @@ using floating       = double; // "float" is a keyward, cannot use it here.
 // - local_date
 // - local_time
 
+#if defined(__GNUC__) && !defined(__clang__)
+#  pragma GCC diagnostic pop
+#endif
+
 // default toml::value and default array/table. these are defined after defining
 // basic_value itself.
 // using value = basic_value<discard_comments, std::unordered_map, std::vector>;
 // using array = typename value::array_type;
 // using table = typename value::table_type;
 
+// to avoid warnings about `value_t::integer` is "shadowing" toml::integer in
+// GCC -Wshadow=global.
+#if defined(__GNUC__) && !defined(__clang__)
+#  pragma GCC diagnostic push
+#  if 7 <= __GNUC__
+#    pragma GCC diagnostic ignored "-Wshadow=global"
+#  else // gcc-6 or older
+#    pragma GCC diagnostic ignored "-Wshadow"
+#  endif
+#endif
 enum class value_t : std::uint8_t
 {
     empty           =  0,
@@ -51,6 +71,9 @@ enum class value_t : std::uint8_t
     array           =  9,
     table           = 10,
 };
+#if defined(__GNUC__) && !defined(__clang__)
+#  pragma GCC diagnostic pop
+#endif
 
 template<typename charT, typename traits>
 inline std::basic_ostream<charT, traits>&
@@ -146,4 +169,5 @@ template<typename T, typename V> struct is_exact_toml_type<T const volatile&, V>
 
 } // detail
 } // toml
+
 #endif// TOML11_TYPES_H

toml/utility.hpp

@@ -2,12 +2,14 @@
 // Distributed under the MIT License.
 #ifndef TOML11_UTILITY_HPP
 #define TOML11_UTILITY_HPP
-#include "traits.hpp"
-#include <utility>
 #include <memory>
 #include <sstream>
+#include <utility>
 
-#if __cplusplus >= 201402L
+#include "traits.hpp"
+#include "version.hpp"
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201402L
 #  define TOML11_MARK_AS_DEPRECATED(msg) [[deprecated(msg)]]
 #elif defined(__GNUC__)
 #  define TOML11_MARK_AS_DEPRECATED(msg) __attribute__((deprecated(msg)))
@@ -20,7 +22,7 @@
 namespace toml
 {
 
-#if __cplusplus >= 201402L
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201402L
 
 using std::make_unique;
 
@@ -32,34 +34,29 @@ inline std::unique_ptr<T> make_unique(Ts&& ... args)
     return std::unique_ptr<T>(new T(std::forward<Ts>(args)...));
 }
 
-#endif // __cplusplus >= 2014
+#endif // TOML11_CPLUSPLUS_STANDARD_VERSION >= 2014
 
 namespace detail
 {
-
-template<typename T>
-inline void resize_impl(T& container, std::size_t N, std::true_type)
+template<typename Container>
+void try_reserve_impl(Container& container, std::size_t N, std::true_type)
 {
-    container.resize(N);
-    return ;
+    container.reserve(N);
+    return;
 }
-
-template<typename T>
-inline void resize_impl(T& container, std::size_t N, std::false_type)
+template<typename Container>
+void try_reserve_impl(Container&, std::size_t, std::false_type) noexcept
 {
-    if(container.size() >= N) {return;}
-
-    throw std::invalid_argument("not resizable type");
+    return;
 }
-
 } // detail
 
-template<typename T>
-inline void resize(T& container, std::size_t N)
+template<typename Container>
+void try_reserve(Container& container, std::size_t N)
 {
-    if(container.size() == N) {return;}
-
-    return detail::resize_impl(container, N, detail::has_resize_method<T>());
+    if(N <= container.size()) {return;}
+    detail::try_reserve_impl(container, N, detail::has_reserve_method<Container>{});
+    return;
 }
 
 namespace detail
@@ -93,5 +90,61 @@ T from_string(const std::string& str, T opt)
     return v;
 }
 
+namespace detail
+{
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201402L
+template<typename T>
+decltype(auto) last_one(T&& tail) noexcept
+{
+    return std::forward<T>(tail);
+}
+
+template<typename T, typename ... Ts>
+decltype(auto) last_one(T&& /*head*/, Ts&& ... tail) noexcept
+{
+    return last_one(std::forward<Ts>(tail)...);
+}
+#else // C++11
+// The following code
+// ```cpp
+//  1 | template<typename T, typename ... Ts>
+//  2 | auto last_one(T&& /*head*/, Ts&& ... tail)
+//  3 |  -> decltype(last_one(std::forward<Ts>(tail)...))
+//  4 | {
+//  5 |     return last_one(std::forward<Ts>(tail)...);
+//  6 | }
+// ```
+// does not work because the function `last_one(...)` is not yet defined at
+// line #3, so `decltype()` cannot deduce the type returned from `last_one`.
+// So we need to determine return type in a different way, like a meta func.
+
+template<typename T, typename ... Ts>
+struct last_one_in_pack
+{
+    using type = typename last_one_in_pack<Ts...>::type;
+};
+template<typename T>
+struct last_one_in_pack<T>
+{
+    using type = T;
+};
+template<typename ... Ts>
+using last_one_in_pack_t = typename last_one_in_pack<Ts...>::type;
+
+template<typename T>
+T&& last_one(T&& tail) noexcept
+{
+    return std::forward<T>(tail);
+}
+template<typename T, typename ... Ts>
+enable_if_t<(sizeof...(Ts) > 0), last_one_in_pack_t<Ts&& ...>>
+last_one(T&& /*head*/, Ts&& ... tail)
+{
+    return last_one(std::forward<Ts>(tail)...);
+}
+
+#endif
+} // detail
+
 }// toml
 #endif // TOML11_UTILITY

toml/version.hpp

@@ -0,0 +1,42 @@
+#ifndef TOML11_VERSION_HPP
+#define TOML11_VERSION_HPP
+
+// This file checks C++ version.
+
+#ifndef __cplusplus
+#    error "__cplusplus is not defined"
+#endif
+
+// Since MSVC does not define `__cplusplus` correctly unless you pass
+// `/Zc:__cplusplus` when compiling, the workaround macros are added.
+// Those enables you to define version manually or to use MSVC specific
+// version macro automatically.
+//
+// The value of `__cplusplus` macro is defined in the C++ standard spec, but
+// MSVC ignores the value, maybe because of backward compatibility. Instead,
+// MSVC defines _MSVC_LANG that has the same value as __cplusplus defined in
+// the C++ standard. First we check the manual version definition, and then
+// we check if _MSVC_LANG is defined. If neither, use normal `__cplusplus`.
+//
+// FYI: https://docs.microsoft.com/en-us/cpp/build/reference/zc-cplusplus?view=msvc-170
+//      https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros?view=msvc-170
+//
+#if   defined(TOML11_ENFORCE_CXX11)
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION 201103L
+#elif defined(TOML11_ENFORCE_CXX14)
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION 201402L
+#elif defined(TOML11_ENFORCE_CXX17)
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION 201703L
+#elif defined(TOML11_ENFORCE_CXX20)
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION 202002L
+#elif defined(_MSVC_LANG) && defined(_MSC_VER) && 1910 <= _MSC_VER
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION _MSVC_LANG
+#else
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION __cplusplus
+#endif
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION < 201103L && _MSC_VER < 1900
+#    error "toml11 requires C++11 or later."
+#endif
+
+#endif// TOML11_VERSION_HPP

toml/visit.hpp

@@ -1,134 +0,0 @@
-//     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