feat: avoid double checking in helper methods

The top-level table has its region at the first character of the file.
That means that, in the case when a key is not found in the top-level
table, the error message points to the first character. If the file has
its first table at the first line, the error message would be like this.
```console
[error] key "a" not found
 --> example.toml
   |
 1 | [table]
   | ^------ in this table
```
It actually points to the top-level table at the first character,
not `[table]`. But it is too confusing. To avoid the confusion, the
error message should explicitly say "key not found in the top-level
table".

.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
@@ -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"
@@ -306,14 +324,8 @@ script:
 - cmake --version
 - mkdir build
 - cd build
-- git clone https://github.com/toml-lang/toml.git
+- echo "COMPILER     = ${COMPILER}"
+- echo "CXX_STANDARD = ${CXX_STANDARD}"
 - cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD -DTOML11_USE_UNRELEASED_TOML_FEATURES=${TOML_HEAD} -Dtoml11_TEST_WITH_ASAN=${WITH_ASAN} -Dtoml11_TEST_WITH_UBSAN=${WITH_UBSAN} ..
 - make
 - ctest --output-on-failure
-
-# https://stackoverflow.com/a/53331571
-before_cache:
-- |
-  if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-    brew cleanup
-  fi

CMakeLists.txt

@@ -1,14 +1,7 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.1)
 enable_testing()
 
-project(toml11)
+project(toml11 VERSION 3.3.1)
-
-set(toml11_VERSION_MAYOR  3)
-set(toml11_VERSION_MINOR  3)
-set(toml11_VERSION_PATCH  1)
-set(toml11_VERSION
-  "${toml11_VERSION_MAYOR}.${toml11_VERSION_MINOR}.${toml11_VERSION_PATCH}"
-)
 
 option(toml11_BUILD_TEST "Build toml tests" ON)
 option(toml11_TEST_WITH_ASAN  "use LLVM address sanitizer" OFF)

README.md

@@ -8,16 +8,17 @@ 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
+- It is 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).
-[TOML v0.5.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.5.0.md)
+- It optionally supports the [unreleased features](#unreleased-toml-features) in the master branch of toml-lang/toml.
-after version 2.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 passes [the language agnostic test suite for TOML parsers by BurntSushi](https://github.com/BurntSushi/toml-test).
+- It has configurable container. You can use any random-access containers and key-value maps as backend containers.
-Not only the test suite itself, a TOML reader/encoder also runs on [CircleCI](https://circleci.com/gh/ToruNiina/toml11).
+- It optionally preserves comments without any overhead.
-You can see the error messages about invalid files and serialization results of valid files at
+- It has configurable serializer that supports comments, inline tables, literal strings and multiline strings.
-[CircleCI](https://circleci.com/gh/ToruNiina/toml11).
+- 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,25 @@ You can see the error messages about invalid files and serialization results of
 
 int main()
 {
-    const auto data = toml::parse("example.toml");
+    auto data = toml::parse("example.toml");
 
-    // title = "an example toml file"
+    // find a value with the specified type from a table
     std::string title = toml::find<std::string>(data, "title");
-    std::cout << "the title is " << title << std::endl;
 
-    // nums = [1, 2, 3, 4, 5]
+    // convert the whole array into any container automatically
     std::vector<int> nums = toml::find<std::vector<int>>(data, "nums");
-    std::cout << "the length of `nums` is" << nums.size() << std::endl;
+
+    // access with STL-like manner
+    if(not data.at("a").contains("b"))
+    {
+        data["a"]["b"] = "c";
+    }
+
+    // pass a fallback
+    std::string name = toml::find_or<std::string>(data, "name", "not found");
+
+    // width-dependent formatting
+    std::cout << std::setw(80) << data << std::endl;
 
     return 0;
 }
@@ -1413,7 +1424,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 +1451,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
@@ -1743,13 +1764,12 @@ 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
+After cloning this repository, run the following command (thank you @jwillikers
-because some of the test codes read a file in the repository.
+for automating test set fetching!).
 
 ```sh
 $ mkdir build
 $ cd build
-$ git clone https://github.com/toml-lang/toml.git
 $ cmake ..
 $ make
 $ make test
@@ -1787,6 +1807,7 @@ I appreciate the help of the contributors who introduced the great feature to th
   - 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
 
 ## Licensing terms
 

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 --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
@@ -158,7 +167,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)

toml/comments.hpp

@@ -81,6 +81,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 +162,7 @@ struct preserve_comments
     {
         return comments.erase(first, last);
     }
+#endif
 
     void swap(preserve_comments& other) {comments.swap(other.comments);}
 

toml/get.hpp

@@ -449,10 +449,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(
+        detail::throw_key_not_found_error(v, ky);
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
     }
     return tab.at(ky);
 }
@@ -463,10 +460,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(
+        detail::throw_key_not_found_error(v, ky);
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
     }
     return tab.at(ky);
 }
@@ -477,10 +471,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(
+        detail::throw_key_not_found_error(v, ky);
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
     }
     return basic_value<C, M, V>(std::move(tab.at(ky)));
 }
@@ -542,10 +533,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(
+        detail::throw_key_not_found_error(v, ky);
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
     }
     return ::toml::get<T>(tab.at(ky));
 }
@@ -558,10 +546,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(
+        detail::throw_key_not_found_error(v, ky);
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
     }
     return ::toml::get<T>(tab.at(ky));
 }
@@ -574,10 +559,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(
+        detail::throw_key_not_found_error(v, ky);
-            "key \"", ky, "\" not found"), {
-                {std::addressof(detail::get_region(v)), "in this table"}
-            }));
     }
     return ::toml::get<T>(std::move(tab.at(ky)));
 }

toml/serializer.hpp

@@ -22,39 +22,62 @@ 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>& key)
 {
+    // check the key can be a bare (unquoted) key
     detail::location<toml::key> loc(key, key);
     detail::lex_unquoted_key::invoke(loc);
     if(loc.iter() == loc.end())
     {
         return key; // all the tokens are consumed. the key is unquoted-key.
     }
-    std::string token("\"");
+
+    //if it includes special characters, then format it in a "quoted" key.
+    std::basic_string<charT, traits, Alloc> serialized("\"");
     for(const char c : key)
     {
         switch(c)
         {
-            case '\\': {token += "\\\\"; break;}
+            case '\\': {serialized += "\\\\"; break;}
-            case '\"': {token += "\\\""; break;}
+            case '\"': {serialized += "\\\""; break;}
-            case '\b': {token += "\\b";  break;}
+            case '\b': {serialized += "\\b";  break;}
-            case '\t': {token += "\\t";  break;}
+            case '\t': {serialized += "\\t";  break;}
-            case '\f': {token += "\\f";  break;}
+            case '\f': {serialized += "\\f";  break;}
-            case '\n': {token += "\\n";  break;}
+            case '\n': {serialized += "\\n";  break;}
-            case '\r': {token += "\\r";  break;}
+            case '\r': {serialized += "\\r";  break;}
-            default  : {token += c;      break;}
+            default  : {serialized += c;      break;}
         }
     }
-    token += "\"";
+    serialized += "\"";
-    return token;
+    return serialized;
 }
 
-template<typename Comment,
+template<typename charT, typename traits, typename Alloc>
-         template<typename ...> class Table,
+std::basic_string<charT, traits, Alloc>
-         template<typename ...> class Array>
+format_keys(const std::vector<std::basic_string<charT, traits, Alloc>>& keys)
+{
+    std::basic_string<charT, traits, Alloc> serialized;
+    if(keys.empty()) {return serialized;}
+
+    for(const auto& ky : keys)
+    {
+        serialized += format_key(ky);
+        serialized += charT('.');
+    }
+    serialized.pop_back(); // remove the last dot '.'
+    return serialized;
+}
+
+template<typename Value>
 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        ;
@@ -270,7 +293,7 @@ struct serializer
                 std::string token;
                 if(!keys_.empty())
                 {
-                    token += this->serialize_key(keys_.back());
+                    token += format_key(keys_.back());
                     token += " = ";
                 }
                 bool failed = false;
@@ -326,7 +349,7 @@ struct serializer
                     }
                 }
                 token += "[[";
-                token += this->serialize_dotted_key(keys_);
+                token += format_keys(keys_);
                 token += "]]\n";
                 token += this->make_multiline_table(item.as_table());
             }
@@ -438,7 +461,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);
@@ -453,7 +476,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);
@@ -462,25 +485,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.
@@ -604,7 +608,7 @@ 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);
@@ -635,7 +639,7 @@ struct serializer
                     token += '\n';
                 }
             }
-            const auto key_and_sep    = this->serialize_key(kv.first) + " = ";
+            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;
@@ -717,6 +721,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())
@@ -727,10 +732,10 @@ format(const basic_value<C, M, V>& v, std::size_t w = 80u,
             oss << v.comments();
             oss << '\n'; // to split the file comment from the first element
         }
-        oss << visit(serializer<C, M, V>(w, fprec, no_comment, false), v);
+        oss << visit(serializer<value_type>(w, fprec, no_comment, false), v);
         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
@@ -766,6 +771,8 @@ 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());
@@ -781,7 +788,7 @@ operator<<(std::basic_ostream<charT, traits>& os, const basic_value<C, M, V>& v)
         os << '\n'; // to split the file comment from the first element
     }
     // the root object can't be an inline table. so pass `false`.
-    os << visit(serializer<C, M, V>(w, fprec, false, no_comment), v);
+    os << visit(serializer<value_type>(w, fprec, false, no_comment), v);
 
     // if v is a non-table value, and has only one comment, then
     // put a comment just after a value. in the following way.

toml/value.hpp

@@ -20,223 +20,145 @@ namespace detail
 {
 
 // to show error messages. not recommended for users.
-template<typename C, template<typename ...> class T, template<typename ...> class A>
+template<typename Value>
-region_base const& get_region(const basic_value<C, T, A>&);
+inline region_base const& get_region(const Value& v)
-template<typename Region,
-         typename C, template<typename ...> class T, template<typename ...> class A>
-void change_region(basic_value<C, T, A>&, Region&&);
-
-template<value_t Expected,
-         typename C, template<typename ...> class T, template<typename ...> class A>
-[[noreturn]] inline void
-throw_bad_cast(value_t actual, const ::toml::basic_value<C, T, A>& v)
 {
-    throw type_error(detail::format_underline(concat_to_string(
+    return *(v.region_info_);
-        "toml::value: bad_cast to ", Expected), {
+}
+
+template<typename Value, typename Region>
+void change_region(Value& v, Region&& reg)
+{
+    using region_type = typename std::remove_reference<
+        typename std::remove_cv<Region>::type
+        >::type;
+
+    std::shared_ptr<region_base> new_reg =
+        std::make_shared<region_type>(std::forward<region_type>(reg));
+    v.region_info_ = new_reg;
+    return;
+}
+
+template<value_t Expected, typename Value>
+[[noreturn]] inline void
+throw_bad_cast(const std::string& funcname, value_t actual, const Value& v)
+{
+    throw type_error(detail::format_underline(
+        concat_to_string(funcname, "bad_cast to ", Expected), {
             {std::addressof(get_region(v)),
              concat_to_string("the actual type is ", actual)}
         }), v.location());
 }
 
-// switch by `value_t` and call the corresponding `value::as_xxx()`. {{{
+// Throw `out_of_range` from `toml::value::at()` and `toml::find()`
+// after generating an error message.
+//
+// The implementation is a bit complicated and there are many edge-cases.
+// If you are not interested in the error message generation, just skip this.
+template<typename Value>
+[[noreturn]] void
+throw_key_not_found_error(const Value& v, const key& ky)
+{
+    // The top-level table has its region at the first character of the file.
+    // That means that, in the case when a key is not found in the top-level
+    // table, the error message points to the first character. If the file has
+    // its first table at the first line, the error message would be like this.
+    // ```console
+    // [error] key "a" not found
+    //  --> example.toml
+    //    |
+    //  1 | [table]
+    //    | ^------ in this table
+    // ```
+    // It actually points to the top-level table at the first character,
+    // not `[table]`. But it is too confusing. To avoid the confusion, the error
+    // message should explicitly say "key not found in the top-level table".
+    const auto& reg = get_region(v);
+    if(reg.line_num() == "1" && reg.size() == 1)
+    {
+        // Here it assumes that top-level table starts at the first character.
+        // The region corresponds to the top-level table will be generated at
+        // `parse_toml_file` function.
+        //     It also assumes that the top-level table size is just one and
+        // the line number is `1`. It is always satisfied. And those conditions
+        // are satisfied only if the table is the top-level table.
+        //
+        // 1. one-character dot-key at the first line
+        // ```toml
+        // a.b = "c"
+        // ```
+        // toml11 counts whole key as the table key. Here, `a.b` is the region
+        // of the table "a". It could be counter intuitive, but it works.
+        // The size of the region is 3, not 1. The above example is the shortest
+        // dot-key example. The size cannot be 1.
+        //
+        // 2. one-character inline-table at the first line
+        // ```toml
+        // a = {b = "c"}
+        // ```
+        // toml11 consideres the inline table body as the table region. Here,
+        // `{b = "c"}` is the region of the table "a". The size of the region
+        // is 9, not 1. The shotest inline table still has two characters, `{`
+        // and `}`. The size cannot be 1.
+        //
+        // 3. one-character table declaration at the first line
+        // ```toml
+        // [a]
+        // ```
+        // toml11 consideres the whole table key as the table region. Here,
+        // `[a]` is the table region. The size is 3, not 1.
+        //
+        throw std::out_of_range(format_underline(concat_to_string(
+            "key \"", ky, "\" not found in the top-level table"), {
+                {std::addressof(reg), "the top-level table starts here"}
+            }));
+    }
+    else
+    {
+        // normal table.
+        throw std::out_of_range(format_underline(concat_to_string(
+            "key \"", ky, "\" not found"), {
+                {std::addressof(reg), "in this table"}
+            }));
+    }
+}
+
+// switch by `value_t` at the compile time.
 template<value_t T>
 struct switch_cast {};
-template<>
+#define TOML11_GENERATE_SWITCH_CASTER(TYPE) \
-struct switch_cast<value_t::boolean>
+    template<>                                                           \
-{
+    struct switch_cast<value_t::TYPE>                                    \
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
+    {                                                                    \
-    static ::toml::boolean& invoke(basic_value<C, T, A>& v) noexcept
+        template<typename Value>                                         \
-    {
+        static typename Value::TYPE##_type& invoke(Value& v)             \
-        return v.as_boolean();
+        {                                                                \
-    }
+            return v.as_##TYPE();                                        \
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
+        }                                                                \
-    static ::toml::boolean const& invoke(basic_value<C, T, A> const& v) noexcept
+        template<typename Value>                                         \
-    {
+        static typename Value::TYPE##_type const& invoke(const Value& v) \
-        return v.as_boolean();
+        {                                                                \
-    }
+            return v.as_##TYPE();                                        \
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
+        }                                                                \
-    static ::toml::boolean&& invoke(basic_value<C, T, A>&& v) noexcept
+        template<typename Value>                                         \
-    {
+        static typename Value::TYPE##_type&& invoke(Value&& v)           \
-        return std::move(v).as_boolean();
+        {                                                                \
-    }
+            return std::move(v).as_##TYPE();                             \
-};
+        }                                                                \
-template<>
+    };                                                                   \
-struct switch_cast<value_t::integer>
+    /**/
-{
+TOML11_GENERATE_SWITCH_CASTER(boolean)
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
+TOML11_GENERATE_SWITCH_CASTER(integer)
-    static ::toml::integer& invoke(basic_value<C, T, A>& v) noexcept
+TOML11_GENERATE_SWITCH_CASTER(floating)
-    {
+TOML11_GENERATE_SWITCH_CASTER(string)
-        return v.as_integer();
+TOML11_GENERATE_SWITCH_CASTER(offset_datetime)
-    }
+TOML11_GENERATE_SWITCH_CASTER(local_datetime)
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
+TOML11_GENERATE_SWITCH_CASTER(local_date)
-    static ::toml::integer const& invoke(basic_value<C, T, A> const& v) noexcept
+TOML11_GENERATE_SWITCH_CASTER(local_time)
-    {
+TOML11_GENERATE_SWITCH_CASTER(array)
-        return v.as_integer();
+TOML11_GENERATE_SWITCH_CASTER(table)
-    }
+
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
+#undef TOML11_GENERATE_SWITCH_CASTER
-    static ::toml::integer&& invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_integer();
-    }
-};
-template<>
-struct switch_cast<value_t::floating>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::floating& invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_floating();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::floating const& invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_floating();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::floating&& invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_floating();
-    }
-};
-template<>
-struct switch_cast<value_t::string>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::string& invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_string();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::string const& invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_string();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::string&& invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_string();
-    }
-};
-template<>
-struct switch_cast<value_t::offset_datetime>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::offset_datetime& invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_offset_datetime();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::offset_datetime const& invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_offset_datetime();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::offset_datetime&& invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_offset_datetime();
-    }
-};
-template<>
-struct switch_cast<value_t::local_datetime>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_datetime& invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_local_datetime();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_datetime const& invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_local_datetime();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_datetime&& invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_local_datetime();
-    }
-};
-template<>
-struct switch_cast<value_t::local_date>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_date& invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_local_date();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_date const& invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_local_date();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_date&& invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_local_date();
-    }
-};
-template<>
-struct switch_cast<value_t::local_time>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_time& invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_local_time();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_time const& invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_local_time();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static ::toml::local_time&& invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_local_time();
-    }
-};
-template<>
-struct switch_cast<value_t::array>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static typename basic_value<C, T, A>::array_type&
-    invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_array();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static typename basic_value<C, T, A>::array_type const&
-    invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_array();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static typename basic_value<C, T, A>::array_type &&
-    invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_array();
-    }
-};
-template<>
-struct switch_cast<value_t::table>
-{
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static typename basic_value<C, T, A>::table_type&
-    invoke(basic_value<C, T, A>& v) noexcept
-    {
-        return v.as_table();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static typename basic_value<C, T, A>::table_type const&
-    invoke(basic_value<C, T, A> const& v) noexcept
-    {
-        return v.as_table();
-    }
-    template<typename C, template<typename ...> class T, template<typename ...> class A>
-    static typename basic_value<C, T, A>::table_type &&
-    invoke(basic_value<C, T, A>&& v) noexcept
-    {
-        return std::move(v).as_table();
-    }
-}; // }}}
 
 }// detail
 
@@ -1255,7 +1177,7 @@ class basic_value
     {
         if(this->type_ != T)
         {
-            detail::throw_bad_cast<T>(this->type_, *this);
+            detail::throw_bad_cast<T>("toml::value::cast: ", this->type_, *this);
         }
         return detail::switch_cast<T>::invoke(*this);
     }
@@ -1264,7 +1186,7 @@ class basic_value
     {
         if(this->type_ != T)
         {
-            detail::throw_bad_cast<T>(this->type_, *this);
+            detail::throw_bad_cast<T>("toml::value::cast: ", this->type_, *this);
         }
         return detail::switch_cast<T>::invoke(*this);
     }
@@ -1273,7 +1195,7 @@ class basic_value
     {
         if(this->type_ != T)
         {
-            detail::throw_bad_cast<T>(this->type_, *this);
+            detail::throw_bad_cast<T>("toml::value::cast: ", this->type_, *this);
         }
         return detail::switch_cast<T>::invoke(std::move(*this));
     }
@@ -1317,13 +1239,14 @@ class basic_value
     // ========================================================================
     // throw version
     // ------------------------------------------------------------------------
-    // const reference
+    // const reference {{{
 
     boolean const& as_boolean() const&
     {
         if(this->type_ != value_t::boolean)
         {
-            detail::throw_bad_cast<value_t::boolean>(this->type_, *this);
+            detail::throw_bad_cast<value_t::boolean>(
+                    "toml::value::as_boolean(): ", this->type_, *this);
         }
         return this->boolean_;
     }
@@ -1331,7 +1254,8 @@ class basic_value
     {
         if(this->type_ != value_t::integer)
         {
-            detail::throw_bad_cast<value_t::integer>(this->type_, *this);
+            detail::throw_bad_cast<value_t::integer>(
+                    "toml::value::as_integer(): ", this->type_, *this);
         }
         return this->integer_;
     }
@@ -1339,7 +1263,8 @@ class basic_value
     {
         if(this->type_ != value_t::floating)
         {
-            detail::throw_bad_cast<value_t::floating>(this->type_, *this);
+            detail::throw_bad_cast<value_t::floating>(
+                    "toml::value::as_floating(): ", this->type_, *this);
         }
         return this->floating_;
     }
@@ -1347,7 +1272,8 @@ class basic_value
     {
         if(this->type_ != value_t::string)
         {
-            detail::throw_bad_cast<value_t::string>(this->type_, *this);
+            detail::throw_bad_cast<value_t::string>(
+                    "toml::value::as_string(): ", this->type_, *this);
         }
         return this->string_;
     }
@@ -1355,7 +1281,8 @@ class basic_value
     {
         if(this->type_ != value_t::offset_datetime)
         {
-            detail::throw_bad_cast<value_t::offset_datetime>(this->type_, *this);
+            detail::throw_bad_cast<value_t::offset_datetime>(
+                    "toml::value::as_offset_datetime(): ", this->type_, *this);
         }
         return this->offset_datetime_;
     }
@@ -1363,7 +1290,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_datetime)
         {
-            detail::throw_bad_cast<value_t::local_datetime>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_datetime>(
+                    "toml::value::as_local_datetime(): ", this->type_, *this);
         }
         return this->local_datetime_;
     }
@@ -1371,7 +1299,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_date)
         {
-            detail::throw_bad_cast<value_t::local_date>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_date>(
+                    "toml::value::as_local_date(): ", this->type_, *this);
         }
         return this->local_date_;
     }
@@ -1379,7 +1308,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_time)
         {
-            detail::throw_bad_cast<value_t::local_time>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_time>(
+                    "toml::value::as_local_time(): ", this->type_, *this);
         }
         return this->local_time_;
     }
@@ -1387,7 +1317,8 @@ class basic_value
     {
         if(this->type_ != value_t::array)
         {
-            detail::throw_bad_cast<value_t::array>(this->type_, *this);
+            detail::throw_bad_cast<value_t::array>(
+                    "toml::value::as_array(): ", this->type_, *this);
         }
         return this->array_.value();
     }
@@ -1395,19 +1326,21 @@ class basic_value
     {
         if(this->type_ != value_t::table)
         {
-            detail::throw_bad_cast<value_t::table>(this->type_, *this);
+            detail::throw_bad_cast<value_t::table>(
+                    "toml::value::as_table(): ", this->type_, *this);
         }
         return this->table_.value();
     }
-
+    // }}}
     // ------------------------------------------------------------------------
-    // nonconst reference
+    // nonconst reference {{{
 
     boolean & as_boolean() &
     {
         if(this->type_ != value_t::boolean)
         {
-            detail::throw_bad_cast<value_t::boolean>(this->type_, *this);
+            detail::throw_bad_cast<value_t::boolean>(
+                    "toml::value::as_boolean(): ", this->type_, *this);
         }
         return this->boolean_;
     }
@@ -1415,7 +1348,8 @@ class basic_value
     {
         if(this->type_ != value_t::integer)
         {
-            detail::throw_bad_cast<value_t::integer>(this->type_, *this);
+            detail::throw_bad_cast<value_t::integer>(
+                    "toml::value::as_integer(): ", this->type_, *this);
         }
         return this->integer_;
     }
@@ -1423,7 +1357,8 @@ class basic_value
     {
         if(this->type_ != value_t::floating)
         {
-            detail::throw_bad_cast<value_t::floating>(this->type_, *this);
+            detail::throw_bad_cast<value_t::floating>(
+                    "toml::value::as_floating(): ", this->type_, *this);
         }
         return this->floating_;
     }
@@ -1431,7 +1366,8 @@ class basic_value
     {
         if(this->type_ != value_t::string)
         {
-            detail::throw_bad_cast<value_t::string>(this->type_, *this);
+            detail::throw_bad_cast<value_t::string>(
+                    "toml::value::as_string(): ", this->type_, *this);
         }
         return this->string_;
     }
@@ -1439,7 +1375,8 @@ class basic_value
     {
         if(this->type_ != value_t::offset_datetime)
         {
-            detail::throw_bad_cast<value_t::offset_datetime>(this->type_, *this);
+            detail::throw_bad_cast<value_t::offset_datetime>(
+                    "toml::value::as_offset_datetime(): ", this->type_, *this);
         }
         return this->offset_datetime_;
     }
@@ -1447,7 +1384,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_datetime)
         {
-            detail::throw_bad_cast<value_t::local_datetime>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_datetime>(
+                    "toml::value::as_local_datetime(): ", this->type_, *this);
         }
         return this->local_datetime_;
     }
@@ -1455,7 +1393,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_date)
         {
-            detail::throw_bad_cast<value_t::local_date>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_date>(
+                    "toml::value::as_local_date(): ", this->type_, *this);
         }
         return this->local_date_;
     }
@@ -1463,7 +1402,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_time)
         {
-            detail::throw_bad_cast<value_t::local_time>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_time>(
+                    "toml::value::as_local_time(): ", this->type_, *this);
         }
         return this->local_time_;
     }
@@ -1471,7 +1411,8 @@ class basic_value
     {
         if(this->type_ != value_t::array)
         {
-            detail::throw_bad_cast<value_t::array>(this->type_, *this);
+            detail::throw_bad_cast<value_t::array>(
+                    "toml::value::as_array(): ", this->type_, *this);
         }
         return this->array_.value();
     }
@@ -1479,19 +1420,22 @@ class basic_value
     {
         if(this->type_ != value_t::table)
         {
-            detail::throw_bad_cast<value_t::table>(this->type_, *this);
+            detail::throw_bad_cast<value_t::table>(
+                    "toml::value::as_table(): ", this->type_, *this);
         }
         return this->table_.value();
     }
 
+    // }}}
     // ------------------------------------------------------------------------
-    // rvalue reference
+    // rvalue reference {{{
 
     boolean && as_boolean() &&
     {
         if(this->type_ != value_t::boolean)
         {
-            detail::throw_bad_cast<value_t::boolean>(this->type_, *this);
+            detail::throw_bad_cast<value_t::boolean>(
+                    "toml::value::as_boolean(): ", this->type_, *this);
         }
         return std::move(this->boolean_);
     }
@@ -1499,7 +1443,8 @@ class basic_value
     {
         if(this->type_ != value_t::integer)
         {
-            detail::throw_bad_cast<value_t::integer>(this->type_, *this);
+            detail::throw_bad_cast<value_t::integer>(
+                    "toml::value::as_integer(): ", this->type_, *this);
         }
         return std::move(this->integer_);
     }
@@ -1507,7 +1452,8 @@ class basic_value
     {
         if(this->type_ != value_t::floating)
         {
-            detail::throw_bad_cast<value_t::floating>(this->type_, *this);
+            detail::throw_bad_cast<value_t::floating>(
+                    "toml::value::as_floating(): ", this->type_, *this);
         }
         return std::move(this->floating_);
     }
@@ -1515,7 +1461,8 @@ class basic_value
     {
         if(this->type_ != value_t::string)
         {
-            detail::throw_bad_cast<value_t::string>(this->type_, *this);
+            detail::throw_bad_cast<value_t::string>(
+                    "toml::value::as_string(): ", this->type_, *this);
         }
         return std::move(this->string_);
     }
@@ -1523,7 +1470,8 @@ class basic_value
     {
         if(this->type_ != value_t::offset_datetime)
         {
-            detail::throw_bad_cast<value_t::offset_datetime>(this->type_, *this);
+            detail::throw_bad_cast<value_t::offset_datetime>(
+                    "toml::value::as_offset_datetime(): ", this->type_, *this);
         }
         return std::move(this->offset_datetime_);
     }
@@ -1531,7 +1479,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_datetime)
         {
-            detail::throw_bad_cast<value_t::local_datetime>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_datetime>(
+                    "toml::value::as_local_datetime(): ", this->type_, *this);
         }
         return std::move(this->local_datetime_);
     }
@@ -1539,7 +1488,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_date)
         {
-            detail::throw_bad_cast<value_t::local_date>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_date>(
+                    "toml::value::as_local_date(): ", this->type_, *this);
         }
         return std::move(this->local_date_);
     }
@@ -1547,7 +1497,8 @@ class basic_value
     {
         if(this->type_ != value_t::local_time)
         {
-            detail::throw_bad_cast<value_t::local_time>(this->type_, *this);
+            detail::throw_bad_cast<value_t::local_time>(
+                    "toml::value::as_local_time(): ", this->type_, *this);
         }
         return std::move(this->local_time_);
     }
@@ -1555,7 +1506,8 @@ class basic_value
     {
         if(this->type_ != value_t::array)
         {
-            detail::throw_bad_cast<value_t::array>(this->type_, *this);
+            detail::throw_bad_cast<value_t::array>(
+                    "toml::value::as_array(): ", this->type_, *this);
         }
         return std::move(this->array_.value());
     }
@@ -1563,10 +1515,12 @@ class basic_value
     {
         if(this->type_ != value_t::table)
         {
-            detail::throw_bad_cast<value_t::table>(this->type_, *this);
+            detail::throw_bad_cast<value_t::table>(
+                    "toml::value::as_table(): ", this->type_, *this);
         }
         return std::move(this->table_.value());
     }
+    // }}}
 
     // accessors =============================================================
     //
@@ -1574,11 +1528,29 @@ class basic_value
     //
     value_type&       at(const key& k)
     {
-        return this->as_table().at(k);
+        if(!this->is_table())
+        {
+            detail::throw_bad_cast<value_t::table>(
+                "toml::value::at(key): ", this->type_, *this);
+        }
+        if(this->as_table(std::nothrow).count(k) == 0)
+        {
+            detail::throw_key_not_found_error(*this, k);
+        }
+        return this->as_table(std::nothrow).at(k);
     }
     value_type const& at(const key& k) const
     {
-        return this->as_table().at(k);
+        if(!this->is_table())
+        {
+            detail::throw_bad_cast<value_t::table>(
+                "toml::value::at(key): ", this->type_, *this);
+        }
+        if(this->as_table(std::nothrow).count(k) == 0)
+        {
+            detail::throw_key_not_found_error(*this, k);
+        }
+        return this->as_table(std::nothrow).at(k);
     }
     value_type&       operator[](const key& k)
     {
@@ -1586,49 +1558,78 @@ class basic_value
         {
             *this = table_type{};
         }
-        return this->as_table()[k];
+        else if(!this->is_table()) // initialized, but not a table
+        {
+            detail::throw_bad_cast<value_t::table>(
+                "toml::value::operator[](key): ", this->type_, *this);
+        }
+        return this->as_table(std::nothrow)[k];
     }
 
     value_type&       at(const std::size_t idx)
     {
+        if(!this->is_array())
+        {
+            detail::throw_bad_cast<value_t::array>(
+                "toml::value::at(idx): ", this->type_, *this);
+        }
+        if(this->as_array(std::nothrow).size() <= idx)
+        {
+            throw std::out_of_range(detail::format_underline(
+                "toml::value::at(idx): no element corresponding to the index", {
+                    {this->region_info_.get(),
+                     concat_to_string("the length is ", this->as_array(std::nothrow).size(),
+                                      ", and the specified index is ", idx)}
+                }));
+        }
         return this->as_array().at(idx);
     }
     value_type const& at(const std::size_t idx) const
     {
-        return this->as_array().at(idx);
+        if(!this->is_array())
+        {
+            detail::throw_bad_cast<value_t::array>(
+                "toml::value::at(idx): ", this->type_, *this);
+        }
+        if(this->as_array(std::nothrow).size() <= idx)
+        {
+            throw std::out_of_range(detail::format_underline(
+                "toml::value::at(idx): no element corresponding to the index", {
+                    {this->region_info_.get(),
+                     concat_to_string("the length is ", this->as_array(std::nothrow).size(),
+                                      ", and the specified index is ", idx)}
+                }));
+        }
+        return this->as_array(std::nothrow).at(idx);
     }
 
     value_type&       operator[](const std::size_t idx) noexcept
     {
+        // no check...
         return this->as_array(std::nothrow)[idx];
     }
     value_type const& operator[](const std::size_t idx) const noexcept
     {
+        // no check...
         return this->as_array(std::nothrow)[idx];
     }
 
     void push_back(const value_type& x)
     {
-        if(this->type_ != value_t::array)
+        if(!this->is_array())
         {
-            throw type_error(detail::format_underline(
+            detail::throw_bad_cast<value_t::array>(
-                "toml::value::push_back(value): bad_cast to array type", {
+                "toml::value::push_back(value): ", this->type_, *this);
-                    {this->region_info_.get(),
-                     concat_to_string("the actual type is ", this->type_)}
-                }), this->location());
         }
         this->as_array(std::nothrow).push_back(x);
         return;
     }
     void push_back(value_type&& x)
     {
-        if(this->type_ != value_t::array)
+        if(!this->is_array())
         {
-            throw type_error(detail::format_underline(
+            detail::throw_bad_cast<value_t::array>(
-                "toml::value::push_back(value): bad_cast to array type", {
+                "toml::value::push_back(value): ", this->type_, *this);
-                    {this->region_info_.get(),
-                     concat_to_string("the actual type is ", this->type_)}
-                }), this->location());
         }
         this->as_array(std::nothrow).push_back(std::move(x));
         return;
@@ -1637,13 +1638,10 @@ class basic_value
     template<typename ... Ts>
     value_type& emplace_back(Ts&& ... args)
     {
-        if(this->type_ != value_t::array)
+        if(!this->is_array())
         {
-            throw type_error(detail::format_underline(
+            detail::throw_bad_cast<value_t::array>(
-                "toml::value::emplace_back(value): bad_cast to array type", {
+                "toml::value::emplace_back(...): ", this->type_, *this);
-                    {this->region_info_.get(),
-                     concat_to_string("the actual type is ", this->type_)}
-                }), this->location());
         }
         this->as_array(std::nothrow).emplace_back(std::forward<Ts>(args) ...);
         return this->as_array(std::nothrow).back();
@@ -1655,15 +1653,15 @@ class basic_value
         {
             case value_t::array:
             {
-                return this->as_array().size();
+                return this->as_array(std::nothrow).size();
             }
             case value_t::table:
             {
-                return this->as_table().size();
+                return this->as_table(std::nothrow).size();
             }
             case value_t::string:
             {
-                return this->as_string().str.size();
+                return this->as_string(std::nothrow).str.size();
             }
             default:
             {
@@ -1678,28 +1676,22 @@ class basic_value
 
     std::size_t count(const key_type& k) const
     {
-        if(this->type_ != value_t::table)
+        if(!this->is_table())
         {
-            throw type_error(detail::format_underline(
+            detail::throw_bad_cast<value_t::table>(
-                "toml::value::count(key): bad_cast to table type", {
+                "toml::value::count(key): ", this->type_, *this);
-                    {this->region_info_.get(),
-                     concat_to_string("the actual type is ", this->type_)}
-                }), this->location());
         }
-        return this->as_table().count(k);
+        return this->as_table(std::nothrow).count(k);
     }
 
     bool contains(const key_type& k) const
     {
-        if(this->type_ != value_t::table)
+        if(!this->is_table())
         {
-            throw type_error(detail::format_underline(
+            detail::throw_bad_cast<value_t::table>(
-                "toml::value::contains(key): bad_cast to table type", {
+                "toml::value::contains(key): ", this->type_, *this);
-                    {this->region_info_.get(),
-                     concat_to_string("the actual type is ", this->type_)}
-                }), this->location());
         }
-        return (this->as_table().count(k) != 0);
+        return (this->as_table(std::nothrow).count(k) != 0);
     }
 
     source_location location() const
@@ -1724,13 +1716,11 @@ class basic_value
     }
 
     // for error messages
-    template<typename C,
+    template<typename Value>
-             template<typename ...> class T, template<typename ...> class A>
+    friend region_base const& detail::get_region(const Value& v);
-    friend region_base const& detail::get_region(const basic_value<C, T, A>&);
 
-    template<typename Region, typename C,
+    template<typename Value, typename Region>
-             template<typename ...> class T, template<typename ...> class A>
+    friend void detail::change_region(Value& v, Region&& reg);
-    friend void detail::change_region(basic_value<C, T, A>&, Region&&);
 
   private:
 
@@ -1760,30 +1750,6 @@ using value = basic_value<discard_comments, std::unordered_map, std::vector>;
 using array = typename value::array_type;
 using table = typename value::table_type;
 
-namespace detail
-{
-template<typename C,
-         template<typename ...> class T, template<typename ...> class A>
-inline region_base const& get_region(const basic_value<C, T, A>& v)
-{
-    return *(v.region_info_);
-}
-
-template<typename Region, typename C,
-         template<typename ...> class T, template<typename ...> class A>
-void change_region(basic_value<C, T, A>& v, Region&& reg)
-{
-    using region_type = typename std::remove_reference<
-        typename std::remove_cv<Region>::type
-        >::type;
-
-    std::shared_ptr<region_base> new_reg =
-        std::make_shared<region_type>(std::forward<region_type>(reg));
-    v.region_info_ = new_reg;
-    return;
-}
-}// detail
-
 template<typename C, template<typename ...> class T, template<typename ...> class A>
 inline bool
 operator==(const basic_value<C, T, A>& lhs, const basic_value<C, T, A>& rhs)