feat: remove deprecated functions

Merge pull request #61 from ToruNiina/as-something
feat: add as_something functions for convenience
2025-12-16 03:08:52 +08:00 · 2019-04-28 15:59:09 +09:00 · 2019-04-28 15:02:19 +09:00 · 2019-04-27 19:04:44 +09:00 · 2019-04-27 18:33:59 +09:00 · 2019-04-27 17:42:12 +09:00
13 changed files with 640 additions and 84 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,7 +5,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-5"
+    env: COMPILER="g++-5" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -16,7 +16,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-6"
+    env: COMPILER="g++-6" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -27,7 +27,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-7"
+    env: COMPILER="g++-7" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -38,7 +38,18 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8"
+    env: COMPILER="g++-8" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-8
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8" CXX_STANDARD=17
    addons:
      apt:
        sources:
@@ -49,7 +60,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-3.7"
+    env: COMPILER="clang++-3.7" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -61,7 +72,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-4.0"
+    env: COMPILER="clang++-4.0" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -73,7 +84,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-5.0"
+    env: COMPILER="clang++-5.0" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -85,7 +96,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-6.0"
+    env: COMPILER="clang++-6.0" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -97,7 +108,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-7"
+    env: COMPILER="clang++-7" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -109,7 +120,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8"
+    env: COMPILER="clang++-8" CXX_STANDARD=11
    addons:
      apt:
        sources:
@@ -118,14 +129,38 @@ matrix:
        packages:
        - clang-8
        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=17
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-8
+        packages:
+        - clang-8
+        - g++-8
+        - libboost-all-dev
  - os: osx
    language: cpp
    compiler: clang
+    env: CXX_STANDARD=11

 script:
+- |
+  if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+    mkdir -p cmake
+    travis_retry wget "https://cmake.org/files/v3.11/cmake-3.11.2-Linux-x86_64.tar.gz"
+    tar xf cmake-3.11.2-Linux-x86_64.tar.gz -C cmake --strip-components=1
+    export PATH=${TRAVIS_BUILD_DIR}/cmake/bin:${PATH}
+  else
+    brew upgrade cmake
+  fi
+- cmake --version
 - mkdir build
 - cd build
 - git clone https://github.com/toml-lang/toml.git
- cmake -DCMAKE_CXX_COMPILER=$COMPILER ..
+- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD ..
 - make
 - ctest --output-on-failure
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,10 @@ project(toml11)

 include(CheckCXXCompilerFlag)
 if("${CMAKE_VERSION}" VERSION_GREATER 3.1)
+    set(CMAKE_CXX_EXTENSIONS OFF)
+    if(NOT DEFINED CMAKE_CXX_STANDARD)
        set(CMAKE_CXX_STANDARD 11)
+    endif()
    set(CXX_STANDARD_REQUIRED ON)
 else()
    # Manually check for C++11 compiler flag.
--- a/README.md
+++ b/README.md
@@ -63,6 +63,7 @@ int main()
 - [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types)
 - [Invalid UTF-8 Codepoints](#invalid-utf-8-codepoints)
 - [Formatting user-defined error messages](#formatting-user-defined-error-messages)
+- [Getting comments related to a value](#getting-comments)
 - [Serializing TOML data](#serializing-toml-data)
 - [Underlying types](#underlying-types)
 - [Running Tests](#running-tests)
@@ -187,6 +188,12 @@ See also [underlying types](#underlying-types).

 NOTE: To enable to get a reference, conversions between Float and Integer are not supported.

+After C++17, you can use `std::string_view` to get a string from a `toml::value`.
+
+```cpp
+const auto sv = toml::get<std::string_view>(tab.at("key"));
+```
+
 ### In the case of type error

 If you pass an invalid type to `toml::get`, `toml::type_error` will be thrown.
@@ -500,9 +507,9 @@ You can check what type of value does `toml::value` contains by `is_*` function.

 ```cpp
 toml::value v = /* ... */;
-if(v.is_integer() && toml::get<int>(v) == 42)
+if(v.is_integer())
 {
-    std::cout << "value is 42" << std::endl;
+    std::cout << "value is an integer" << std::endl;
 }
 ```

@@ -546,6 +553,36 @@ toml::value v = /* ... */;
 if(v.is(toml::value_t::Boolean)) // ...
 ```

+## Casting value
+
+So far, `toml::get` is introduced, but if you don't need any type conversion,
+`as_*` is simpler to use.
+
+```cpp
+toml::value v = /* ... */;
+if(v.is_integer() && v.as_integer() == 42)
+{
+    std::cout << "value is 42" << std::endl;
+}
+```
+
+The complete list of the functions is below.
+
+```cpp
+const toml::value v(/*...*/);
+v.as_boolean();
+v.as_integer();
+v.as_float();
+v.as_string();
+v.as_offset_datetime();
+v.as_local_datetime();
+v.as_local_date();
+v.as_local_time();
+v.as_array();
+v.as_table();
+v.as_uninitialized();
+```
+
 ## Visiting a toml::value

 toml11 provides `toml::visit` to apply a function to `toml::value` in the
@@ -618,7 +655,7 @@ add a comma after the first element (like `[1,]`).
 "[[table]]"_toml; // This is a table that has an array of tables inside.

 "[[1]]"_toml;     // This literal is ambiguous.
-                  // Currently, it becomes a table taht has array of table "1".
+                  // Currently, it becomes a table that has array of table "1".
 "1 = [{}]"_toml;  // This is a table that has an array of table named 1.
 "[[1,]]"_toml;    // This is an array of arrays.
 "[[1],]"_toml;    // ditto.
@@ -831,6 +868,53 @@ you will get an error message like this.
   |       ~~ maximum number here
 ```

+## Getting comments
+
+Since toml11 keeps a file data until all the values are destructed, you can
+also extract a comment related to a value by calling `toml::value::comment()`.
+
+If there is a comment just after a value (within the same line), you can get
+the specific comment by `toml::value::comment_inline()`.
+
+If there are comments just before a value (without any newline between them),
+you can get the comments by `toml::value::comment_before()`.
+
+`toml::value::comment()` returns the results of both functions after
+concatenating them.
+
+```toml
+a = 42 # comment for a.
+
+# comment for b.
+# this is also a comment for b.
+b = "foo"
+
+c = [ # comment for c.
+    3.14, # this is not a comment for c, but for 3.14.
+] # this is also a comment for c.
+```
+
+```cpp
+// "# comment for a."
+const std::string com1 = toml::find(data, "a").comment();
+
+// "# comment for b."
+const std::string com2 = toml::find(data, "b").comment();
+
+// "# comment for c.\n# this is also a comment for c."
+const std::string com3 = toml::find(data, "c").comment();
+
+// "# this is not a comment for c, but for 3.14."
+const std::string com3 = toml::find<toml::array>(data, "c").front().comment();
+```
+
+Note that once a data in a value is modified, the related file region
+information would be deleted. Thus after modifying a data, you cannot find any
+comments.
+
+Also note that currently it does not support any way to set a comment to a value.
+And currently, serializer does not take comments into account.
+
 ## Serializing TOML data

 toml11 (after v2.1.0) enables you to serialize data into toml format.
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -21,6 +21,7 @@ set(TEST_NAMES
    test_parse_key
    test_parse_table_key
    test_literals
+    test_comments
    test_get
    test_get_related_func
    test_from_toml
--- a/tests/test_comments.cpp
+++ b/tests/test_comments.cpp
@@ -0,0 +1,125 @@
+#define BOOST_TEST_MODULE "test_comments"
+#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>
+
+BOOST_AUTO_TEST_CASE(test_comment_before)
+{
+    using namespace toml::literals::toml_literals;
+    {
+        const toml::value v = u8R"(
+            # comment for a.
+            a = 42
+            # comment for b.
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), u8"# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), "");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8"# comment for b.");
+    }
+
+    {
+        const toml::value v = u8R"(
+            # comment for a.
+            # another comment for a.
+            a = 42
+            # comment for b.
+            # also comment for b.
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), u8R"(# comment for a.
+# another comment for a.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), u8R"(# comment for b.
+# also comment for b.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), u8"");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), u8"");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8R"(# comment for a.
+# another comment for a.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8R"(# comment for b.
+# also comment for b.)");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_comment_inline)
+{
+    using namespace toml::literals::toml_literals;
+    {
+        const toml::value v = u8R"(
+            a = 42    # comment for a.
+            b = "baz" # comment for b.
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), u8"# comment for b.");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8"# comment for b.");
+    }
+    {
+        const toml::value v = u8R"(
+            a = [    # comment for a.
+                42,
+            ] # this also.
+            b = [ # comment for b.
+                "bar",
+            ]
+            c = [
+                3.14, # this is not a comment for c, but 3.14.
+            ] # comment for c.
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "c").comment_before(), "");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), u8R"(# comment for a.
+# this also.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), u8"# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "c").comment_inline(), u8"# comment for c.");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(),  u8R"(# comment for a.
+# this also.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8"# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "c").comment(), u8"# comment for c.");
+
+        const auto& c0 = toml::find<toml::array>(v, "c").at(0);
+        BOOST_CHECK_EQUAL(c0.comment(), u8"# this is not a comment for c, but 3.14.");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_comment_both)
+{
+    using namespace toml::literals::toml_literals;
+    {
+        const toml::value v = u8R"(
+            # comment for a.
+            a = 42 # inline comment for a.
+            # comment for b.
+            b = "baz" # inline comment for b.
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), "# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), "# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), "# inline comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), "# inline comment for b.");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8R"(# comment for a.
+# inline comment for a.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8R"(# comment for b.
+# inline comment for b.)");
+    }
+}
--- a/tests/test_get.cpp
+++ b/tests/test_get.cpp
@@ -12,6 +12,9 @@
 #include <list>
 #include <deque>
 #include <array>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif


 BOOST_AUTO_TEST_CASE(test_get_exact)
@@ -166,6 +169,17 @@ BOOST_AUTO_TEST_CASE(test_get_string_type)
        toml::get<std::string>(v) += "bar";
        BOOST_CHECK_EQUAL("foobar", toml::get<std::string>(v));
    }
+
+#if __cplusplus >= 201703L
+    {
+        toml::value v("foo", toml::string_t::basic);
+        BOOST_CHECK_EQUAL("foo", toml::get<std::string_view>(v));
+    }
+    {
+        toml::value v("foo", toml::string_t::literal);
+        BOOST_CHECK_EQUAL("foo", toml::get<std::string_view>(v));
+    }
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_get_toml_array)
--- a/tests/test_value.cpp
+++ b/tests/test_value.cpp
@@ -9,6 +9,11 @@
 #include <map>
 #include <list>

+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
+
+
 BOOST_AUTO_TEST_CASE(test_value_boolean)
 {
    toml::value v1(true);
@@ -25,6 +30,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), false);

    v1 = false;
    v2 = true;
@@ -40,6 +47,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), false);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), false);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), true);

    toml::value v3(v1);
    toml::value v4(v2);
@@ -57,6 +66,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Boolean>(), false);
    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v3.as_boolean(), false);
+    BOOST_CHECK_EQUAL(v4.as_boolean(), true);

    toml::value v5(std::move(v1));
    toml::value v6(std::move(v2));
@@ -72,6 +83,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)

    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::Boolean>(), false);
    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v5.as_boolean(), false);
+    BOOST_CHECK_EQUAL(v6.as_boolean(), true);

    v1 = 42;
    v2 = 3.14;
@@ -87,6 +100,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), 42);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Float>(),   3.14);
+    BOOST_CHECK_EQUAL(v1.as_integer(),  42);
+    BOOST_CHECK_EQUAL(v2.as_float(), 3.14);
 }

 BOOST_AUTO_TEST_CASE(test_value_integer)
@@ -105,6 +120,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), -42);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(),  42u);
+    BOOST_CHECK_EQUAL(v1.as_integer(), -42);
+    BOOST_CHECK_EQUAL(v2.as_integer(),  42u);

    v1 = 54;
    v2 = -54;
@@ -120,6 +137,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(),  54);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(), -54);
+    BOOST_CHECK_EQUAL(v1.as_integer(),  54);
+    BOOST_CHECK_EQUAL(v2.as_integer(), -54);

    toml::value v3(v1);
    toml::value v4(v2);
@@ -137,6 +156,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Integer>(),  54);
    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Integer>(), -54);
+    BOOST_CHECK_EQUAL(v3.as_integer(),  54);
+    BOOST_CHECK_EQUAL(v4.as_integer(), -54);

    toml::value v5(std::move(v1));
    toml::value v6(std::move(v2));
@@ -152,6 +173,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)

    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::Integer>(),  54);
    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Integer>(), -54);
+    BOOST_CHECK_EQUAL(v5.as_integer(),  54);
+    BOOST_CHECK_EQUAL(v6.as_integer(), -54);

    v1 = true;
    v2 = false;
@@ -167,6 +190,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), false);
 }

 BOOST_AUTO_TEST_CASE(test_value_float)
@@ -183,8 +208,10 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v1.is_float());
    BOOST_CHECK(v2.is_float());

-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Float>(), 3.14);
+    BOOST_CHECK_EQUAL         (v1.cast<toml::value_t::Float>(), 3.14);
    BOOST_CHECK_CLOSE_FRACTION(v2.cast<toml::value_t::Float>(), 3.14, 1e-2);
+    BOOST_CHECK_EQUAL         (v1.as_float(), 3.14);
+    BOOST_CHECK_CLOSE_FRACTION(v2.as_float(), 3.14, 1e-2);

    v1 = 2.718f;
    v2 = 2.718;
@@ -199,7 +226,9 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v2.is_float());

    BOOST_CHECK_CLOSE_FRACTION(v1.cast<toml::value_t::Float>(), 2.718, 1e-3);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_EQUAL         (v2.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_CLOSE_FRACTION(v1.as_float(), 2.718, 1e-3);
+    BOOST_CHECK_EQUAL         (v2.as_float(), 2.718);

    toml::value v3(v1);
    toml::value v4(v2);
@@ -216,7 +245,9 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v4.is_float());

    BOOST_CHECK_CLOSE_FRACTION(v3.cast<toml::value_t::Float>(), 2.718, 1e-3);
-    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_EQUAL         (v4.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_CLOSE_FRACTION(v3.as_float(), 2.718, 1e-3);
+    BOOST_CHECK_EQUAL         (v4.as_float(), 2.718);

    toml::value v5(std::move(v1));
    toml::value v6(std::move(v2));
@@ -231,7 +262,9 @@ BOOST_AUTO_TEST_CASE(test_value_float)
    BOOST_CHECK(v6.is_float());

    BOOST_CHECK_CLOSE_FRACTION(v5.cast<toml::value_t::Float>(), 2.718, 1e-3);
-    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_EQUAL         (v6.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_CLOSE_FRACTION(v5.as_float(), 2.718, 1e-3);
+    BOOST_CHECK_EQUAL         (v6.as_float(), 2.718);

    v1 = true;
    v2 = false;
@@ -247,6 +280,8 @@ BOOST_AUTO_TEST_CASE(test_value_float)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), false);
 }

 BOOST_AUTO_TEST_CASE(test_value_string)
@@ -271,6 +306,10 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::String>(), "foo");
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::String>(), "foo");
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::String>(), "foo");
+    BOOST_CHECK_EQUAL(v1.as_string(), "foo");
+    BOOST_CHECK_EQUAL(v2.as_string(), "foo");
+    BOOST_CHECK_EQUAL(v3.as_string(), "foo");
+

    v1 = "bar";
    v2 = "bar";
@@ -289,6 +328,10 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::String>(), "bar");
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::String>(), "bar");
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::String>(), "bar");
+    BOOST_CHECK_EQUAL(v1.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v2.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v3.as_string(), "bar");
+

    toml::value v4(v1);
    toml::value v5(v2);
@@ -313,6 +356,10 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::String>(), "bar");
    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::String>(), "bar");
    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::String>(), "bar");
+    BOOST_CHECK_EQUAL(v4.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v5.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v6.as_string(), "bar");
+

    v4.cast<toml::value_t::String>().str.at(2) = 'z';
    v5.cast<toml::value_t::String>().str.at(2) = 'z';
@@ -331,9 +378,9 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK(v5.is_string());
    BOOST_CHECK(v6.is_string());

-    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::String>(), "baz");
-    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::String>(), "baz");
-    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::String>(), "baz");
+    BOOST_CHECK_EQUAL(v4.as_string(), "baz");
+    BOOST_CHECK_EQUAL(v5.as_string(), "baz");
+    BOOST_CHECK_EQUAL(v6.as_string(), "baz");

    v1 = true;
    v2 = true;
@@ -355,6 +402,28 @@ BOOST_AUTO_TEST_CASE(test_value_string)
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), true);
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v3.as_boolean(), true);
+
+#if __cplusplus >= 201703L
+    std::string_view sv = "foo";
+
+    toml::value v7(sv);
+    toml::value v8(sv, toml::string_t::literal);
+
+    BOOST_CHECK_EQUAL(v7.type(), toml::value_t::String);
+    BOOST_CHECK_EQUAL(v8.type(), toml::value_t::String);
+    BOOST_CHECK(v7.is(toml::value_t::String));
+    BOOST_CHECK(v8.is(toml::value_t::String));
+    BOOST_CHECK(v7.is<toml::String>());
+    BOOST_CHECK(v8.is<toml::String>());
+    BOOST_CHECK(v7.is_string());
+    BOOST_CHECK(v8.is_string());
+
+    BOOST_CHECK_EQUAL(v7.cast<toml::value_t::String>(), "foo");
+    BOOST_CHECK_EQUAL(v8.cast<toml::value_t::String>(), "foo");
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_value_local_date)
@@ -368,6 +437,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
                      toml::local_date(2018, toml::month_t::Jan, 31));
+    BOOST_CHECK_EQUAL(v1.as_local_date(),
+                      toml::local_date(2018, toml::month_t::Jan, 31));

    v1 = toml::local_date(2018, toml::month_t::Apr, 1);

@@ -378,6 +449,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
                      toml::local_date(2018, toml::month_t::Apr, 1));
+    BOOST_CHECK_EQUAL(v1.as_local_date(),
+                      toml::local_date(2018, toml::month_t::Apr, 1));

    toml::value v2(v1);
    BOOST_CHECK(v2 == v1);
@@ -389,6 +462,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)

    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalDate>(),
                      toml::local_date(2018, toml::month_t::Apr, 1));
+    BOOST_CHECK_EQUAL(v2.as_local_date(),
+                      toml::local_date(2018, toml::month_t::Apr, 1));

    v1 = true;
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -396,6 +471,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }

 BOOST_AUTO_TEST_CASE(test_value_local_time)
@@ -415,10 +491,18 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)

    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                      toml::local_time(12, 30, 45));
+    BOOST_CHECK_EQUAL(v1.as_local_time(),
+                      toml::local_time(12, 30, 45));
+
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalTime>(),
                      toml::local_time(12, 30, 45));
+    BOOST_CHECK_EQUAL(v2.as_local_time(),
+                      toml::local_time(12, 30, 45));
+
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                      v2.cast<toml::value_t::LocalTime>());
+    BOOST_CHECK_EQUAL(v1.as_local_time(),
+                      v2.as_local_time());

    v1 = toml::local_time(1, 30, 0, /*ms*/ 100, /*us*/ 0);

@@ -428,6 +512,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
    BOOST_CHECK(v1.is_local_time());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                      toml::local_time(1, 30, 0, 100, 0));
+    BOOST_CHECK_EQUAL(v1.as_local_time(),
+                      toml::local_time(1, 30, 0, 100, 0));

    toml::value v3(v1);
    BOOST_CHECK(v3 == v1);
@@ -439,6 +525,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)

    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::LocalTime>(),
                      toml::local_time(1, 30, 0, 100, 0));
+    BOOST_CHECK_EQUAL(v3.as_local_time(),
+                      toml::local_time(1, 30, 0, 100, 0));

    v1 = true;
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -446,6 +534,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }

 BOOST_AUTO_TEST_CASE(test_value_local_datetime)
@@ -464,6 +553,10 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
                      toml::local_datetime(
                          toml::local_date(2018, toml::month_t::Jan, 31),
                          toml::local_time(12, 30, 45)));
+    BOOST_CHECK_EQUAL(v1.as_local_datetime(),
+                      toml::local_datetime(
+                          toml::local_date(2018, toml::month_t::Jan, 31),
+                          toml::local_time(12, 30, 45)));

    v1 = toml::local_datetime(
                toml::local_date(2018, toml::month_t::Apr, 1),
@@ -478,6 +571,10 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
                      toml::local_datetime(
                          toml::local_date(2018, toml::month_t::Apr, 1),
                          toml::local_time(1, 15, 30)));
+    BOOST_CHECK_EQUAL(v1.as_local_datetime(),
+                      toml::local_datetime(
+                          toml::local_date(2018, toml::month_t::Apr, 1),
+                          toml::local_time(1, 15, 30)));

    toml::value v2(v1);
    BOOST_CHECK(v2 == v1);
@@ -491,6 +588,11 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
                      toml::local_datetime(
                          toml::local_date(2018, toml::month_t::Apr, 1),
                          toml::local_time(1, 15, 30)));
+    BOOST_CHECK_EQUAL(v2.as_local_datetime(),
+                      toml::local_datetime(
+                          toml::local_date(2018, toml::month_t::Apr, 1),
+                          toml::local_time(1, 15, 30)));
+

    v1 = true;
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -498,6 +600,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }

 BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
@@ -519,6 +622,12 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
                toml::local_time(12, 30, 45),
                toml::time_offset(9, 0)
                ));
+    BOOST_CHECK_EQUAL(v1.as_offset_datetime(),
+            toml::offset_datetime(
+                toml::local_date(2018, toml::month_t::Jan, 31),
+                toml::local_time(12, 30, 45),
+                toml::time_offset(9, 0)
+                ));

    v1 = toml::offset_datetime(
                toml::local_date(2018, toml::month_t::Apr, 1),
@@ -535,6 +644,12 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
                toml::local_date(2018, toml::month_t::Apr, 1),
                toml::local_time(1, 15, 30),
                toml::time_offset(9, 0)));
+    BOOST_CHECK_EQUAL(v1.as_offset_datetime(),
+            toml::offset_datetime(
+                toml::local_date(2018, toml::month_t::Apr, 1),
+                toml::local_time(1, 15, 30),
+                toml::time_offset(9, 0)));
+

    toml::value v2(v1);
    BOOST_CHECK(v2 == v1);
@@ -549,12 +664,19 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
                toml::local_date(2018, toml::month_t::Apr, 1),
                toml::local_time(1, 15, 30),
                toml::time_offset(9, 0)));
+    BOOST_CHECK_EQUAL(v2.as_offset_datetime(),
+            toml::offset_datetime(
+                toml::local_date(2018, toml::month_t::Apr, 1),
+                toml::local_time(1, 15, 30),
+                toml::time_offset(9, 0)));
+
    v1 = true;
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
    BOOST_CHECK(v1.is(toml::value_t::Boolean));
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }

 BOOST_AUTO_TEST_CASE(test_value_array)
@@ -578,6 +700,12 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 3);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 4);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 5);
+    BOOST_CHECK_EQUAL(v1.as_array().at(0).as_integer(), 1);
+    BOOST_CHECK_EQUAL(v1.as_array().at(1).as_integer(), 2);
+    BOOST_CHECK_EQUAL(v1.as_array().at(2).as_integer(), 3);
+    BOOST_CHECK_EQUAL(v1.as_array().at(3).as_integer(), 4);
+    BOOST_CHECK_EQUAL(v1.as_array().at(4).as_integer(), 5);
+

    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 6);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 7);
@@ -603,12 +731,24 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 8);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 9);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 0);
+    BOOST_CHECK_EQUAL(v1.as_array().at(0).as_integer(), 6);
+    BOOST_CHECK_EQUAL(v1.as_array().at(1).as_integer(), 7);
+    BOOST_CHECK_EQUAL(v1.as_array().at(2).as_integer(), 8);
+    BOOST_CHECK_EQUAL(v1.as_array().at(3).as_integer(), 9);
+    BOOST_CHECK_EQUAL(v1.as_array().at(4).as_integer(), 0);
+

    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 1);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 2);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 3);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 4);
    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 5);
+    BOOST_CHECK_EQUAL(v2.as_array().at(0).as_integer(), 1);
+    BOOST_CHECK_EQUAL(v2.as_array().at(1).as_integer(), 2);
+    BOOST_CHECK_EQUAL(v2.as_array().at(2).as_integer(), 3);
+    BOOST_CHECK_EQUAL(v2.as_array().at(3).as_integer(), 4);
+    BOOST_CHECK_EQUAL(v2.as_array().at(4).as_integer(), 5);
+

    toml::value v3(v1);
    BOOST_CHECK(v3 == v1);
@@ -623,6 +763,12 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 8);
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 9);
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 0);
+    BOOST_CHECK_EQUAL(v3.as_array().at(0).as_integer(), 6);
+    BOOST_CHECK_EQUAL(v3.as_array().at(1).as_integer(), 7);
+    BOOST_CHECK_EQUAL(v3.as_array().at(2).as_integer(), 8);
+    BOOST_CHECK_EQUAL(v3.as_array().at(3).as_integer(), 9);
+    BOOST_CHECK_EQUAL(v3.as_array().at(4).as_integer(), 0);
+

    v1 = true;
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -630,6 +776,7 @@ BOOST_AUTO_TEST_CASE(test_value_array)
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }

 BOOST_AUTO_TEST_CASE(test_value_table)
@@ -644,6 +791,10 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Integer>(),    42);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Float>(),      3.14);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("baz").cast<toml::value_t::String>().str, "qux");
+    BOOST_CHECK_EQUAL(v1.as_table().at("foo").as_integer(),    42);
+    BOOST_CHECK_EQUAL(v1.as_table().at("bar").as_float(),   3.14);
+    BOOST_CHECK_EQUAL(v1.as_table().at("baz").as_string().str, "qux");
+

    v1 = toml::table{{"foo", 2.71}, {"bar", 54}, {"baz", "quux"}};

@@ -655,6 +806,10 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Float>(),      2.71);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Integer>(),    54);
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("baz").cast<toml::value_t::String>().str, "quux");
+    BOOST_CHECK_EQUAL(v1.as_table().at("foo").as_float(),   2.71);
+    BOOST_CHECK_EQUAL(v1.as_table().at("bar").as_integer(),    54);
+    BOOST_CHECK_EQUAL(v1.as_table().at("baz").as_string().str, "quux");
+

    toml::value v3(v1);
    BOOST_CHECK(v3 == v1);
@@ -667,6 +822,10 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Float>(),      2.71);
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Integer>(),    54);
    BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("baz").cast<toml::value_t::String>().str, "quux");
+    BOOST_CHECK_EQUAL(v3.as_table().at("foo").as_float(),   2.71);
+    BOOST_CHECK_EQUAL(v3.as_table().at("bar").as_integer(),    54);
+    BOOST_CHECK_EQUAL(v3.as_table().at("baz").as_string().str, "quux");
+

    v1 = true;
    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -674,6 +833,7 @@ BOOST_AUTO_TEST_CASE(test_value_table)
    BOOST_CHECK(v1.is<toml::Boolean>());
    BOOST_CHECK(v1.is_boolean());
    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }

 BOOST_AUTO_TEST_CASE(test_value_empty)
--- a/toml/get.hpp
+++ b/toml/get.hpp
@@ -108,6 +108,18 @@ inline std::string get(value&& v)
    return std::move(v.cast<value_t::String>().str);
 }

+// ============================================================================
+// std::string_view
+
+#if __cplusplus >= 201703L
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string_view>::value, std::nullptr_t>::type = nullptr>
+inline std::string_view get(const value& v)
+{
+    return std::string_view(v.cast<value_t::String>().str);
+}
+#endif
+
 // ============================================================================
 // std::chrono::duration from toml::local_time.

@@ -546,67 +558,6 @@ T get_or(const toml::value& v, T&& opt)
    }
 }

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

--- a/toml/literal.hpp
+++ b/toml/literal.hpp
@@ -73,6 +73,9 @@ inline ::toml::value operator""_toml(const char* str, std::size_t len)
    if(auto data = ::toml::detail::parse_toml_file(loc))
    {
        loc.reset(loc.begin()); // rollback to the top of the literal
+        // skip needless characters for error message
+        skip_line::invoke(loc); // skip the first several needless lines
+        skip_ws::invoke(loc);   // skip the first several needless whitespaces
        return ::toml::value(std::move(data.unwrap()),
                ::toml::detail::region<std::vector<char>>(std::move(loc)));
    }
--- a/toml/region.hpp
+++ b/toml/region.hpp
@@ -52,6 +52,14 @@ struct region_base
    virtual std::size_t before()   const noexcept {return 0;}
    // number of characters in the line after the region
    virtual std::size_t after()    const noexcept {return 0;}
+
+    virtual std::string comment_before() const {return "";} // just before
+    virtual std::string comment_inline() const {return "";} // in the same line
+    virtual std::string comment()        const {return "";} // concatenate
+    // ```toml
+    // # comment_before
+    // key = "value" # comment_inline
+    // ```
 };

 // location represents a position in a container, which contains a file content.
@@ -280,6 +288,92 @@ struct region final : public region_base

    std::string name() const override {return source_name_;}

+    std::string comment_before() const override
+    {
+        auto iter = this->line_begin(); // points the first element
+        std::vector<std::pair<decltype(iter), decltype(iter)>> comments;
+        while(iter != this->begin())
+        {
+            iter = std::prev(iter);
+            using rev_iter = std::reverse_iterator<decltype(iter)>;
+            auto line_before = std::find(rev_iter(iter), rev_iter(this->begin()),
+                                         '\n').base();
+            // range [line_before, iter) represents the previous line
+
+            auto comment_found = std::find(line_before, iter, '#');
+            if(iter != comment_found && std::all_of(line_before, comment_found,
+                    [](const char c) noexcept -> bool {
+                        return c == ' ' || c == '\t';
+                    }))
+            {
+                // the line before this range contains only a comment.
+                comments.push_back(std::make_pair(comment_found, iter));
+            }
+            else
+            {
+                break;
+            }
+            iter = line_before;
+        }
+
+        std::string com;
+        for(auto i = comments.crbegin(), e = comments.crend(); i!=e; ++i)
+        {
+            if(i != comments.crbegin()) {com += '\n';}
+            com += std::string(i->first, i->second);
+        }
+        return com;
+    }
+
+    std::string comment_inline() const override
+    {
+        if(this->contain_newline())
+        {
+            std::string com;
+            // check both the first and the last line.
+            const auto first_line_end =
+                std::find(this->line_begin(), this->last(), '\n');
+            const auto first_comment_found =
+                std::find(this->line_begin(), first_line_end, '#');
+
+            if(first_comment_found != first_line_end)
+            {
+                com += std::string(first_comment_found, first_line_end);
+            }
+
+            const auto last_comment_found =
+                std::find(this->last(), this->line_end(), '#');
+            if(last_comment_found != this->line_end())
+            {
+                if(!com.empty()){com += '\n';}
+                com += std::string(last_comment_found, this->line_end());
+            }
+            return com;
+        }
+        const auto comment_found =
+            std::find(this->line_begin(), this->line_end(), '#');
+        return std::string(comment_found, this->line_end());
+    }
+
+    std::string comment() const override
+    {
+        std::string com_bef = this->comment_before();
+        std::string com_inl = this->comment_inline();
+        if(!com_bef.empty() && !com_inl.empty())
+        {
+            com_bef += '\n';
+            return com_bef + com_inl;
+        }
+        else if(com_bef.empty())
+        {
+            return com_inl;
+        }
+        else
+        {
+            return com_bef;
+        }
+    }
+
  private:

    source_ptr     source_;
@@ -343,7 +437,8 @@ inline std::string format_underline(const std::string& message,
        {
            // invalid
            // ~~~~~~~
-            retval << make_string(reg->size(), '~');
+            const auto underline_len = std::min(reg->size(), reg->line().size());
+            retval << make_string(underline_len, '~');
        }

        retval << ' ';
--- a/toml/string.hpp
+++ b/toml/string.hpp
@@ -4,6 +4,11 @@
 #define TOML11_STRING_HPP
 #include <string>
 #include <cstdint>
+#if __cplusplus >= 201703L
+#if __has_include(<string_view>)
+#include <string_view>
+#endif
+#endif

 namespace toml
 {
@@ -40,6 +45,17 @@ struct string
    operator std::string const& () const& noexcept {return str;}
    operator std::string&&      () &&     noexcept {return std::move(str);}

+#if __cplusplus >= 201703L
+    explicit string(std::string_view s): kind(string_t::basic), str(s){}
+    string(std::string_view s, string_t k): kind(k), str(s){}
+
+    string& operator=(std::string_view s)
+    {kind = string_t::basic; str = s; return *this;}
+
+    explicit operator std::string_view() const noexcept
+    {return std::string_view(str);}
+#endif
+
    string_t    kind;
    std::string str;
 };
--- a/toml/types.hpp
+++ b/toml/types.hpp
@@ -7,6 +7,11 @@
 #include "traits.hpp"
 #include <vector>
 #include <unordered_map>
+#if __cplusplus >= 201703L
+#if __has_include(<string_view>)
+#include <string_view>
+#endif
+#endif

 namespace toml
 {
@@ -172,6 +177,9 @@ template<typename T>
 struct is_container : conjunction<
    negation<is_map<T>>,
    negation<std::is_same<T, std::string>>,
+#if __cplusplus >= 201703L
+    negation<std::is_same<T, std::string_view>>,
+#endif
    has_iterator<T>,
    has_value_type<T>
    >{};
--- a/toml/value.hpp
+++ b/toml/value.hpp
@@ -14,6 +14,9 @@
 #include <unordered_map>
 #include <cassert>
 #include <cstdint>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif

 namespace toml
 {
@@ -293,6 +296,29 @@ class value
        assigner(this->string_, toml::string(std::string(s), kind));
    }

+#if __cplusplus >= 201703L
+    value(std::string_view s)
+        : type_(value_t::String),
+          region_info_(std::make_shared<region_base>(region_base{}))
+    {
+        assigner(this->string_, toml::string(s));
+    }
+    value& operator=(std::string_view s)
+    {
+        this->cleanup();
+        this->type_ = value_t::String;
+        this->region_info_ = std::make_shared<region_base>(region_base{});
+        assigner(this->string_, toml::string(s));
+        return *this;
+    }
+    value(std::string_view s, string_t kind)
+        : type_(value_t::String),
+          region_info_(std::make_shared<region_base>(region_base{}))
+    {
+        assigner(this->string_, toml::string(s, kind));
+    }
+#endif
+
    // local date ===========================================================

    value(const local_date& ld)
@@ -607,6 +633,41 @@ class value
    template<value_t T>
    typename detail::toml_default_type<T>::type&&      cast() &&;

+    boolean         const& as_boolean()         const {return this->cast<value_t::Boolean       >();}
+    integer         const& as_integer()         const {return this->cast<value_t::Integer       >();}
+    floating        const& as_float()           const {return this->cast<value_t::Float         >();}
+    string          const& as_string()          const {return this->cast<value_t::String        >();}
+    offset_datetime const& as_offset_datetime() const {return this->cast<value_t::OffsetDatetime>();}
+    local_datetime  const& as_local_datetime()  const {return this->cast<value_t::LocalDatetime >();}
+    local_date      const& as_local_date()      const {return this->cast<value_t::LocalDate     >();}
+    local_time      const& as_local_time()      const {return this->cast<value_t::LocalTime     >();}
+    array           const& as_array()           const {return this->cast<value_t::Array         >();}
+    table           const& as_table()           const {return this->cast<value_t::Table         >();}
+
+    boolean&          as_boolean()         {return this->cast<value_t::Boolean       >();}
+    integer&          as_integer()         {return this->cast<value_t::Integer       >();}
+    floating&         as_float()           {return this->cast<value_t::Float         >();}
+    string&           as_string()          {return this->cast<value_t::String        >();}
+    offset_datetime&  as_offset_datetime() {return this->cast<value_t::OffsetDatetime>();}
+    local_datetime&   as_local_datetime()  {return this->cast<value_t::LocalDatetime >();}
+    local_date&       as_local_date()      {return this->cast<value_t::LocalDate     >();}
+    local_time&       as_local_time()      {return this->cast<value_t::LocalTime     >();}
+    array&            as_array()           {return this->cast<value_t::Array         >();}
+    table&            as_table()           {return this->cast<value_t::Table         >();}
+
+    std::string comment() const
+    {
+        return this->region_info_->comment();
+    }
+    std::string comment_before() const
+    {
+        return this->region_info_->comment_before();
+    }
+    std::string comment_inline() const
+    {
+        return this->region_info_->comment_inline();
+    }
+
  private:

    void cleanup() noexcept
Author	SHA1	Message	Date
ToruNiina	87be890e07	feat: remove deprecated functions	2019-04-28 15:59:09 +09:00
Toru Niina	d72dc706d0	Merge pull request #61 from ToruNiina/as-something feat: add as_something functions for convenience	2019-04-28 15:02:19 +09:00
ToruNiina	4cbbcd8f62	Merge branch 'master' into as-something	2019-04-27 19:04:44 +09:00
Toru Niina	a2631ecacb	Merge pull request #60 from ToruNiina/string-view support std::string_view	2019-04-27 18:33:59 +09:00
ToruNiina	4bcc5e8375	Merge branch 'master' into as-something	2019-04-27 17:42:12 +09:00
Toru Niina	90f84000ba	Merge pull request #59 from ToruNiina/preserve-comments Preserve comments; related to #48	2019-04-27 17:40:26 +09:00
ToruNiina	20a13754a7	chore: update README for as_* functions	2019-04-27 16:50:44 +09:00
ToruNiina	aa7b9a3965	refactor: rename as_floating -> as_float Actually, since `floating` is used for toml::types, `as_floating` seems to be clearer. But currently `is_*` functions uses `float`, not `floating`, so `as_float` is chosen for the consistency. In a future release, possibly v3, those names may need to be re-considered for clarity.	2019-04-27 16:45:25 +09:00
ToruNiina	84ac1d10f3	test: add test for toml::value::as_something	2019-04-27 16:22:50 +09:00
ToruNiina	0d623856a7	feat: add value::as_something() for convenience	2019-04-27 16:22:23 +09:00
ToruNiina	ec0d4e4e8c	chore: update README for comments	2019-04-27 15:50:54 +09:00
ToruNiina	80ea736b3f	ci: try to update standard library on travis	2019-04-27 14:46:40 +09:00
ToruNiina	ebaa5dfb51	chore: fix build settings for OS X on Travis	2019-04-26 21:10:29 +09:00
ToruNiina	f3bdf083fe	fix: fix typo in test code for string_view	2019-04-26 16:51:23 +09:00
ToruNiina	1ce54a9cf9	chore: add auto test with c++17 + latest compilers	2019-04-26 16:35:03 +09:00
ToruNiina	6383a93ce7	chore: check CXX_STANDARD exists or not	2019-04-26 16:33:48 +09:00
ToruNiina	01aa2ef5b2	feat: add ctor to value to init with string_view	2019-04-26 16:33:09 +09:00
ToruNiina	819351f5a4	test: add test for init toml::value by string_view	2019-04-26 16:32:23 +09:00
ToruNiina	2967cebfb3	test: add test to get a toml::value as string_view	2019-04-26 16:31:59 +09:00
ToruNiina	32e9a2c1c7	test: add test for comments in an array	2019-04-26 15:35:41 +09:00
ToruNiina	8e0a40a1aa	test: add test for getting comments	2019-04-25 22:34:12 +09:00
ToruNiina	e460826084	feat: enable to get a comment related to a value - comment_before(): get comments just before a value. - comment_inline(): get a comment in the same line as a value. - comment(): get comment_before() + comment_inline().	2019-04-25 22:32:39 +09:00
ToruNiina	aa3445f38c	feat: add functions to get comments around region	2019-04-25 22:32:18 +09:00
ToruNiina	408b7bf35e	Merge branch 'master' into string-view	2019-04-23 23:32:08 +09:00
ToruNiina	6185dfee14	chore: fix typo in README	2019-04-23 23:31:37 +09:00
ToruNiina	37aa2739a5	chore: add description about string_view to README	2019-04-23 23:27:53 +09:00
ToruNiina	d061c33a16	feat: enable toml::get with std::string_view	2019-04-23 23:24:23 +09:00
ToruNiina	0c7d2d07d4	feat: do not consider string_view as a container it is a kind of string.	2019-04-23 23:23:57 +09:00
ToruNiina	62cf4373bd	feat: conversion toml::string <-> string_view	2019-04-22 23:18:05 +09:00
Toru Niina	a74ad23514	Merge pull request #58 from ToruNiina/improve-err-msg-literal Improve error message from toml literal	2019-04-22 20:50:11 +09:00
ToruNiina	2d9b4992ec	fix: restrict length of underline by size of line in some cases, `region` contains several lines and `region::size` returns the whole size that is a sum of lengthes of all the lines. To avoid too long underlines, restrict the length of underline by the length of the line that is shown in the message.	2019-04-21 16:38:08 +09:00
ToruNiina	82e8c1e68b	fix: skip first ws/newlines in toml literal when ""_toml literal is used with C++11 raw-string literal, it normally starts with newline like the following. ```cpp const auto v = u8R"( [table] key = "value" )"_toml; ``` With this, the error message shows the first empty line that starts just after `u8R"(` and thus the error message shows nothing. To avoid this, skip the first empty lines and whitespaces in literal.	2019-04-21 16:31:24 +09:00