From 4bbca20fc1525bca9d982d0bd092f3bc908184a9 Mon Sep 17 00:00:00 2001
From: Mark Gillard <marzer_@hotmail.com>
Date: Thu, 5 Mar 2020 13:07:26 +0200
Subject: [PATCH] added `node::ref()` and `node_view::ref()` (resolves #10)

also:
- simplified `const` handling in `node_view`
---
 README.md                       |   2 -
 include/toml++/toml_node.h      |  94 +++++++++++++----
 include/toml++/toml_node_view.h | 152 ++++++++++-----------------
 include/toml++/toml_version.h   |   4 +-
 meson.build                     |   2 +-
 tests/main.cpp                  |   1 +
 tests/tests.cpp                 |  29 +++++
 tests/tests.h                   |   7 +-
 toml.hpp                        | 181 ++++++++++++++++----------------
 9 files changed, 261 insertions(+), 211 deletions(-)

diff --git a/README.md b/README.md
index 713cb10d..f063dbe0 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,6 @@ Given a TOML file `configuration.toml` containing the following:
 ```toml
 [library]
 name = "toml++"
-version = "0.3.3"
 authors = ["Mark Gillard <mark@notarealwebsite.com>"]
 
 [dependencies]
@@ -35,7 +34,6 @@ auto config = toml::parse_file( "configuration.toml" );
 
 // get key-value pairs
 std::string_view library_name = config["library"]["name"].value_or(""sv);
-std::string_view library_version = config["library"]["version"].value_or(""sv);
 std::string_view library_author = config["library"]["authors"][0].value_or(""sv);
 int64_t depends_on_cpp_version = config["dependencies"]["cpp"].value_or(0);
 
diff --git a/include/toml++/toml_node.h b/include/toml++/toml_node.h
index 2e82ac1a..d9f26305 100644
--- a/include/toml++/toml_node.h
+++ b/include/toml++/toml_node.h
@@ -91,7 +91,7 @@ TOML_START
 				using type = impl::unwrapped<impl::remove_cvref_t<T>>;
 				static_assert(
 					impl::is_value_or_node<type>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
 				);
 
 					 if constexpr (std::is_same_v<type, table>) return is_table();
@@ -218,7 +218,7 @@ TOML_START
 				using type = impl::unwrapped<T>;
 				static_assert(
 					impl::is_value_or_node<type>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
 				);
 
 					 if constexpr (std::is_same_v<type, table>) return as_table();
@@ -240,7 +240,7 @@ TOML_START
 				using type = impl::unwrapped<T>;
 				static_assert(
 					impl::is_value_or_node<type>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
 				);
 
 					 if constexpr (std::is_same_v<type, table>) return as_table();
@@ -321,11 +321,12 @@ TOML_START
 			template <typename A, typename B>
 			using nonvoid = std::conditional_t<std::is_void_v<A>, B, A>;
 
-			//# this is done using a static helper to preserve const and ref categories
-			//# (otherwise I'd have to implement this function thrice)
+			//# these functions are static helpers to preserve const and ref categories
+			//# (otherwise I'd have to implement them thrice)
 			//# ((propagation in C++: a modern horror story))
+
 			template <typename N, typename FUNC>
-			static decltype(auto) do_visit(N&& node, FUNC&& visitor)
+			static decltype(auto) do_visit(N&& n, FUNC&& visitor)
 				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, N&&>)
 			{
 				static_assert(
@@ -333,51 +334,51 @@ TOML_START
 					"Visitors must be invocable for at least one of the toml::node specializations"
 				);
 
-				switch (node.type())
+				switch (n.type())
 				{
 					case node_type::table:
 						if constexpr (can_visit<FUNC&&, N&&, table>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<table>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<table>());
 						break;
 
 					case node_type::array:
 						if constexpr (can_visit<FUNC&&, N&&, array>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<array>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<array>());
 						break;
 
 					case node_type::string:
 						if constexpr (can_visit<FUNC&&, N&&, string>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<string>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<string>());
 						break;
 
 					case node_type::integer:
 						if constexpr (can_visit<FUNC&&, N&&, int64_t>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<int64_t>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<int64_t>());
 						break;
 
 					case node_type::floating_point:
 						if constexpr (can_visit<FUNC&&, N&&, double>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<double>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<double>());
 						break;
 
 					case node_type::boolean:
 						if constexpr (can_visit<FUNC&&, N&&, bool>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<bool>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<bool>());
 						break;
 
 					case node_type::date:
 						if constexpr (can_visit<FUNC&&, N&&, date>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<date>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<date>());
 						break;
 
 					case node_type::time:
 						if constexpr (can_visit<FUNC&&, N&&, time>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<time>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<time>());
 						break;
 
 					case node_type::date_time:
 						if constexpr (can_visit<FUNC&&, N&&, date_time>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<date_time>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<date_time>());
 						break;
 
 					TOML_NO_DEFAULT_CASE;
@@ -410,6 +411,25 @@ TOML_START
 				}
 			}
 
+
+			template <typename T, typename N>
+			[[nodiscard]] static decltype(auto) do_ref(N&& n) noexcept
+			{
+				using type = impl::unwrapped<T>;
+				static_assert(
+					impl::is_value_or_node<type>,
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
+				);
+				TOML_ASSERT(
+					n.template is<T>()
+					&& "template type argument T provided to toml::node::ref() didn't match the node's actual type"
+				);
+				if constexpr (impl::is_value<type>)
+					return std::forward<N>(n).template ref_cast<type>().get();
+				else
+					return std::forward<N>(n).template ref_cast<type>();
+			}
+
 		public:
 
 			/// \brief	Invokes a visitor on the node based on the node's concrete type.
@@ -446,19 +466,57 @@ TOML_START
 				return do_visit(*this, std::forward<FUNC>(visitor));
 			}
 
-			/// \brief	Invokes a visitor on the node based on the node's concrete type (rvalue overload).
 			template <typename FUNC>
 			decltype(auto) visit(FUNC&& visitor) && TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, node&&>)
 			{
 				return do_visit(std::move(*this), std::forward<FUNC>(visitor));
 			}
 
-			/// \brief	Invokes a visitor on the node based on the node's concrete type (const overload).
 			template <typename FUNC>
 			decltype(auto) visit(FUNC&& visitor) const& TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, const node&>)
 			{
 				return do_visit(*this, std::forward<FUNC>(visitor));
 			}
+
+			/// \brief	Gets a raw reference to a value node's underlying data.
+			///
+			/// \warning This function is dangerous if used carelessly and **WILL** break your code if the chosen value type
+			/// 		 doesn't match the node's actual type. If you provide a definition for `TOML_ASSERT`
+			/// 		 (explicitly or indirectly by including `<cassert>`) an assertion will fire when
+			/// 		 invalid accesses are attempted: \cpp
+			///
+			/// auto tbl = toml::parse(R"(
+			/// 
+			///	min = 32
+			///	max = 45
+			///	
+			/// )"sv);
+			/// 
+			/// auto& min_ref = tbl.get("min")->ref<int64_t>(); // this is OK
+			/// auto& max_ref = tbl.get("max")->ref<double>();  // hits assertion because the type is wrong
+			///
+			/// \ecpp
+			/// 
+			/// \tparam	T	One of the TOML value types.
+			///
+			/// \returns	A reference to the underlying data.
+			template <typename T>
+			[[nodiscard]] impl::unwrapped<T>& ref() & noexcept
+			{
+				return do_ref<T>(*this);
+			}
+
+			template <typename T>
+			[[nodiscard]] impl::unwrapped<T>&& ref() && noexcept
+			{
+				return do_ref<T>(std::move(*this));
+			}
+
+			template <typename T>
+			[[nodiscard]] const impl::unwrapped<T>& ref() const& noexcept
+			{
+				return do_ref<T>(*this);
+			}
 	};
 }
 TOML_END
diff --git a/include/toml++/toml_node_view.h b/include/toml++/toml_node_view.h
index da90ab4a..d2af51ea 100644
--- a/include/toml++/toml_node_view.h
+++ b/include/toml++/toml_node_view.h
@@ -61,22 +61,23 @@ TOML_START
 			friend class toml::table;
 			template <typename U> friend class toml::node_view;
 
-			viewed_type* node_;
+			mutable viewed_type* node_;
 
 			TOML_NODISCARD_CTOR
 			node_view(viewed_type* node) noexcept
 				: node_{ node }
 			{}
 
+			template <typename FUNC>
+			static constexpr bool visit_is_nothrow
+				= noexcept(std::declval<viewed_type*>()->visit(std::declval<FUNC&&>()));
+
 		public:
 
 			/// \brief	Returns true if the view references a node.
 			[[nodiscard]] explicit operator bool() const noexcept { return node_ != nullptr; }
 			/// \brief	Returns the node that's being referenced by the view.
-			[[nodiscard]] viewed_type* get() noexcept { return node_; }
-			/// \brief	Returns the node that's being referenced by the view (const overload).
-			[[nodiscard]] const viewed_type* get() const noexcept { return node_; }
-
+			[[nodiscard]] viewed_type* get() const noexcept { return node_; }
 
 			/// \brief	Returns the type identifier for the viewed node.
 			[[nodiscard]] node_type type() const noexcept { return node_ ? node_->type() : node_type::none; }
@@ -129,20 +130,7 @@ TOML_START
 			/// \see toml::node::as()
 			template <typename U>
 			[[nodiscard]]
-			auto as() noexcept
-			{
-				static_assert(
-					impl::is_value_or_node<impl::unwrapped<U>>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
-				);
-
-				return node_ ? node_->template as<U>() : nullptr;
-			}
-
-			/// \brief	Gets a pointer to the viewed node as a more specific node type (const overload).
-			template <typename U>
-			[[nodiscard]]
-			const impl::node_of<U>* as() const noexcept
+			auto as() const noexcept
 			{
 				static_assert(
 					impl::is_value_or_node<impl::unwrapped<U>>,
@@ -153,42 +141,23 @@ TOML_START
 			}
 
 			/// \brief	Returns a pointer to the viewed node as a toml::table, if it is one.
-			[[nodiscard]] auto as_table() noexcept { return as<table>(); }
+			[[nodiscard]] auto as_table() const noexcept { return as<table>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::array, if it is one.
-			[[nodiscard]] auto as_array() noexcept { return as<array>(); }
+			[[nodiscard]] auto as_array() const noexcept { return as<array>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::value<string>, if it is one.
-			[[nodiscard]] auto as_string() noexcept { return as<string>(); }
+			[[nodiscard]] auto as_string() const noexcept { return as<string>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::value<int64_t>, if it is one.
-			[[nodiscard]] auto as_integer() noexcept { return as<int64_t>(); }
+			[[nodiscard]] auto as_integer() const noexcept { return as<int64_t>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::value<double>, if it is one.
-			[[nodiscard]] auto as_floating_point() noexcept { return as<double>(); }
+			[[nodiscard]] auto as_floating_point() const noexcept { return as<double>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::value<bool>, if it is one.
-			[[nodiscard]] auto as_boolean() noexcept { return as<bool>(); }
+			[[nodiscard]] auto as_boolean() const noexcept { return as<bool>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::value<date>, if it is one.
-			[[nodiscard]] auto as_date() noexcept { return as<date>(); }
+			[[nodiscard]] auto as_date() const noexcept { return as<date>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::value<time>, if it is one.
-			[[nodiscard]] auto as_time() noexcept { return as<time>(); }
+			[[nodiscard]] auto as_time() const noexcept { return as<time>(); }
 			/// \brief	Returns a pointer to the viewed node as a toml::value<date_time>, if it is one.
-			[[nodiscard]] auto as_date_time() noexcept { return as<date_time>(); }
-
-			/// \brief	Returns a pointer to the viewed node as a toml::table, if it is one (const overload).
-			[[nodiscard]] const table* as_table() const noexcept { return as<table>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::array, if it is one (const overload).
-			[[nodiscard]] const array* as_array() const noexcept { return as<array>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::value<string>, if it is one (const overload).
-			[[nodiscard]] const toml::value<string>* as_string() const noexcept { return as<string>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::value<int64_t>, if it is one (const overload).
-			[[nodiscard]] const toml::value<int64_t>* as_integer() const noexcept { return as<int64_t>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::value<double>, if it is one (const overload).
-			[[nodiscard]] const toml::value<double>* as_floating_point() const noexcept { return as<double>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::value<bool>, if it is one (const overload).
-			[[nodiscard]] const toml::value<bool>* as_boolean() const noexcept { return as<bool>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::value<date>, if it is one (const overload).
-			[[nodiscard]] const toml::value<date>* as_date() const noexcept { return as<date>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::value<time>, if it is one (const overload).
-			[[nodiscard]] const toml::value<time>* as_time() const noexcept { return as<time>(); }
-			/// \brief	Returns a pointer to the viewed node as a toml::value<date_time>, if it is one (const overload).
-			[[nodiscard]] const toml::value<date_time>* as_date_time() const noexcept { return as<date_time>(); }
+			[[nodiscard]] auto as_date_time() const noexcept { return as<date_time>(); }
 
 			/// \brief	Gets the raw value contained by the referenced node.
 			/// 
@@ -224,47 +193,58 @@ TOML_START
 				return return_type{ std::forward<U>(default_value) };
 			}
 
-		private:
-
-			template <typename N, typename FUNC>
-			static decltype(auto) do_visit(N* node, FUNC&& visitor)
-				TOML_MAY_THROW_UNLESS(noexcept(std::declval<N*>()->visit(std::declval<FUNC&&>())))
-			{
-				using return_type = decltype(node->visit(std::forward<FUNC>(visitor)));
-				if (node)
-					return node->visit(std::forward<FUNC>(visitor));
-				if constexpr (!std::is_void_v<return_type>)
-					return return_type{};
-			}
-
-			template <typename FUNC, typename N>
-			static constexpr bool visit_is_nothrow =
-				noexcept(do_visit(std::declval<N*>(), std::declval<FUNC&&>()));
-
-		public:
-
 			/// \brief	Invokes a visitor on the viewed node based on its concrete type.
 			/// 
 			/// \remarks Has no effect if the view does not reference a node.
 			/// 
 			/// \see node::visit()
 			template <typename FUNC>
-			decltype(auto) visit(FUNC&& visitor)
-				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, viewed_type>)
+			decltype(auto) visit(FUNC&& visitor) const
+				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&>)
 			{
-				return do_visit(node_, std::forward<FUNC>(visitor));
+				using return_type = decltype(node_->visit(std::forward<FUNC>(visitor)));
+				if (node_)
+					return node_->visit(std::forward<FUNC>(visitor));
+				if constexpr (!std::is_void_v<return_type>)
+					return return_type{};
 			}
 
-			/// \brief	Invokes a visitor on the viewed node based on its concrete type (const overload).
+			/// \brief	Gets a raw reference to the viewed node's underlying data.
+			///
+			/// \warning This function is dangerous if used carelessly and **WILL** break your code if the 
+			/// 		 node_view didn't reference a node, or the chosen value type doesn't match the node's
+			/// 		 actual type. If you provide a definition for TOML_ASSERT (explicitly or indirectly
+			/// 		 by including `<cassert>`) an assertion will fire when invalid accesses are attempted: \cpp
+			///
+			/// auto tbl = toml::parse(R"(
+			///	
+			///	min = 32
+			///	max = 45
 			/// 
-			/// \remarks Has no effect if the view does not reference a node.
+			/// )"sv);
 			/// 
-			///  \see node::visit()
-			template <typename FUNC>
-			decltype(auto) visit(FUNC&& visitor) const
-				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, const viewed_type>)
+			/// auto& min_ref = tbl["min"].ref<int64_t>(); // this is OK
+			/// auto& max_ref = tbl["max"].ref<double>(); // hits assertion because the type is wrong
+			/// auto& min_ref = tbl["foo"].ref<int64_t>(); // hits assertion because "foo" didn't exist
+			///
+			/// \ecpp
+			/// 
+			/// \tparam	U	One of the TOML value types.
+			///
+			/// \returns	A reference to the underlying data.
+			template <typename U>
+			[[nodiscard]] decltype(auto) ref() const noexcept
 			{
-				return do_visit(node_, std::forward<FUNC>(visitor));
+				using type = impl::unwrapped<U>;
+				static_assert(
+					impl::is_value_or_node<type>,
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
+				);
+				TOML_ASSERT(
+					node_
+					&& "toml::node_view::ref() called on a node_view that did not reference a node"
+				);
+				return node_->template ref<type>();
 			}
 
 			/// \brief	Returns true if the viewed node is a table with the same contents as RHS.
@@ -335,15 +315,7 @@ TOML_START
 			///
 			/// \returns	A view of the selected node if this node represented a table and it contained a
 			/// 			value at the given key, or an empty view.
-			[[nodiscard]] node_view operator[] (string_view key) noexcept
-			{
-				if (auto tbl = this->as_table())
-					return { tbl->get(key) };
-				return { nullptr };
-			}
-
-			/// \brief	Returns a view of the selected subnode (const overload).
-			[[nodiscard]] node_view<const viewed_type> operator[] (string_view key) const noexcept
+			[[nodiscard]] node_view operator[] (string_view key) const noexcept
 			{
 				if (auto tbl = this->as_table())
 					return { tbl->get(key) };
@@ -356,15 +328,7 @@ TOML_START
 			///
 			/// \returns	A view of the selected node if this node represented an array and it contained a
 			/// 			value at the given index, or an empty view.
-			[[nodiscard]] node_view operator[] (size_t index) noexcept
-			{
-				if (auto arr = this->as_array())
-					return { arr->get(index) };
-				return { nullptr };
-			}
-
-			/// \brief	Returns a view of the selected subnode (const overload).
-			[[nodiscard]] node_view<const viewed_type> operator[] (size_t index) const noexcept
+			[[nodiscard]] node_view operator[] (size_t index) const noexcept
 			{
 				if (auto arr = this->as_array())
 					return { arr->get(index) };
diff --git a/include/toml++/toml_version.h b/include/toml++/toml_version.h
index 99c5b777..88b8e8bf 100644
--- a/include/toml++/toml_version.h
+++ b/include/toml++/toml_version.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #define TOML_LIB_MAJOR		0
-#define TOML_LIB_MINOR		3
-#define TOML_LIB_PATCH		3
+#define TOML_LIB_MINOR		4
+#define TOML_LIB_PATCH		0
 
 #define TOML_LANG_MAJOR		0
 #define TOML_LANG_MINOR		5
diff --git a/meson.build b/meson.build
index 18682c80..a8f4b8c2 100644
--- a/meson.build
+++ b/meson.build
@@ -1,7 +1,7 @@
 project(
 	'tomlplusplus',
 	'cpp',
-	version : '0.3.3',
+	version : '0.4.0',
 	license : 'MIT',
 	default_options : [
 		'cpp_std=c++17',
diff --git a/tests/main.cpp b/tests/main.cpp
index f0e4374e..355c4fe8 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -7,6 +7,7 @@
 	#define TOML_OPTIONAL_TYPE tl::optional
 #endif
 
+#include <cassert> //so TOML_ASSERT() maps to assert()
 #define TOML_ALL_INLINE 0
 #define TOML_IMPLEMENTATION
 #include "../include/toml++/toml.h"
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 3bbc2a1e..77608f5c 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -59,3 +59,32 @@ namespace Catch
 
 #endif // TESTS_MANUAL_INSTANTIATIONS
 
+TOML_START
+{
+	using std::declval;
+	using std::is_same_v;
+
+	static_assert(is_same_v<decltype(declval<node&>().ref<double>()), double&>);
+	static_assert(is_same_v<decltype(declval<node&&>().ref<double>()), double&&>);
+	static_assert(is_same_v<decltype(declval<const node&>().ref<double>()), const double&>);
+	static_assert(is_same_v<decltype(declval<node&>().ref<value<double>>()), double&>);
+	static_assert(is_same_v<decltype(declval<node&&>().ref<value<double>>()), double&&>);
+	static_assert(is_same_v<decltype(declval<const node&>().ref<value<double>>()), const double&>);
+	static_assert(is_same_v<decltype(declval<node&>().ref<table>()), table&>);
+	static_assert(is_same_v<decltype(declval<node&&>().ref<table>()), table&&>);
+	static_assert(is_same_v<decltype(declval<const node&>().ref<table>()), const table&>);
+	static_assert(is_same_v<decltype(declval<node&>().ref<array>()), array&>);
+	static_assert(is_same_v<decltype(declval<node&&>().ref<array>()), array&&>);
+	static_assert(is_same_v<decltype(declval<const node&>().ref<array>()), const array&>);
+
+	static_assert(is_same_v<decltype(declval<node_view<node>>().ref<double>()), double&>);
+	static_assert(is_same_v<decltype(declval<node_view<const node>>().ref<double>()), const double&>);
+	static_assert(is_same_v<decltype(declval<node_view<node>>().ref<value<double>>()), double&>);
+	static_assert(is_same_v<decltype(declval<node_view<const node>>().ref<value<double>>()), const double&>);
+	static_assert(is_same_v<decltype(declval<node_view<node>>().ref<table>()), table&>);
+	static_assert(is_same_v<decltype(declval<node_view<const node>>().ref<table>()), const table&>);
+	static_assert(is_same_v<decltype(declval<node_view<node>>().ref<array>()), array&>);
+	static_assert(is_same_v<decltype(declval<node_view<const node>>().ref<array>()), const array&>);
+
+}
+TOML_END
diff --git a/tests/tests.h b/tests/tests.h
index 29caeda4..8ac6d4b9 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -7,11 +7,12 @@
 	#endif
 	#define TOML_OPTIONAL_TYPE tl::optional
 #endif
+#include "catch2.h"
+#include <sstream>
+#include <cassert> //so TOML_ASSERT() maps to assert()
 #define TOML_UNDEF_MACROS 0
 #define TOML_ALL_INLINE 0
 #include "../include/toml++/toml.h"
-#include "catch2.h"
-#include <sstream>
 
 using namespace toml;
 using namespace Catch::literals;
@@ -230,6 +231,8 @@ inline void parse_expected_value(std::string_view value_str, const T& expected)
 		CHECK(nv.as<value_type>()->get() == expected);
 		CHECK(nv.value<value_type>() == expected);
 		CHECK(nv.value_or(T{}) == expected);
+		CHECK(nv.ref<value_type>() == expected);
+		CHECK(nv.get()->ref<value_type>() == expected);
 
 		// check the table relops
 		CHECK(tbl == table{ { { S("val"sv), expected } } });
diff --git a/toml.hpp b/toml.hpp
index f25db0d6..0313ad16 100644
--- a/toml.hpp
+++ b/toml.hpp
@@ -1,6 +1,6 @@
 //----------------------------------------------------------------------------------------------------------------------
 //
-// toml++ v0.3.3
+// toml++ v0.4.0
 // https://github.com/marzer/tomlplusplus
 // SPDX-License-Identifier: MIT
 //
@@ -308,8 +308,8 @@
 #endif
 
 #define TOML_LIB_MAJOR		0
-#define TOML_LIB_MINOR		3
-#define TOML_LIB_PATCH		3
+#define TOML_LIB_MINOR		4
+#define TOML_LIB_PATCH		0
 
 #define TOML_LANG_MAJOR		0
 #define TOML_LANG_MINOR		5
@@ -1595,7 +1595,7 @@ TOML_START
 				using type = impl::unwrapped<impl::remove_cvref_t<T>>;
 				static_assert(
 					impl::is_value_or_node<type>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
 				);
 
 					 if constexpr (std::is_same_v<type, table>) return is_table();
@@ -1641,7 +1641,7 @@ TOML_START
 				using type = impl::unwrapped<T>;
 				static_assert(
 					impl::is_value_or_node<type>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
 				);
 
 					 if constexpr (std::is_same_v<type, table>) return as_table();
@@ -1662,7 +1662,7 @@ TOML_START
 				using type = impl::unwrapped<T>;
 				static_assert(
 					impl::is_value_or_node<type>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
 				);
 
 					 if constexpr (std::is_same_v<type, table>) return as_table();
@@ -1743,7 +1743,7 @@ TOML_START
 			using nonvoid = std::conditional_t<std::is_void_v<A>, B, A>;
 
 			template <typename N, typename FUNC>
-			static decltype(auto) do_visit(N&& node, FUNC&& visitor)
+			static decltype(auto) do_visit(N&& n, FUNC&& visitor)
 				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, N&&>)
 			{
 				static_assert(
@@ -1751,51 +1751,51 @@ TOML_START
 					"Visitors must be invocable for at least one of the toml::node specializations"
 				);
 
-				switch (node.type())
+				switch (n.type())
 				{
 					case node_type::table:
 						if constexpr (can_visit<FUNC&&, N&&, table>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<table>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<table>());
 						break;
 
 					case node_type::array:
 						if constexpr (can_visit<FUNC&&, N&&, array>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<array>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<array>());
 						break;
 
 					case node_type::string:
 						if constexpr (can_visit<FUNC&&, N&&, string>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<string>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<string>());
 						break;
 
 					case node_type::integer:
 						if constexpr (can_visit<FUNC&&, N&&, int64_t>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<int64_t>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<int64_t>());
 						break;
 
 					case node_type::floating_point:
 						if constexpr (can_visit<FUNC&&, N&&, double>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<double>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<double>());
 						break;
 
 					case node_type::boolean:
 						if constexpr (can_visit<FUNC&&, N&&, bool>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<bool>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<bool>());
 						break;
 
 					case node_type::date:
 						if constexpr (can_visit<FUNC&&, N&&, date>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<date>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<date>());
 						break;
 
 					case node_type::time:
 						if constexpr (can_visit<FUNC&&, N&&, time>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<time>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<time>());
 						break;
 
 					case node_type::date_time:
 						if constexpr (can_visit<FUNC&&, N&&, date_time>)
-							return std::forward<FUNC>(visitor)(std::forward<N>(node).template ref_cast<date_time>());
+							return std::forward<FUNC>(visitor)(std::forward<N>(n).template ref_cast<date_time>());
 						break;
 
 					TOML_NO_DEFAULT_CASE;
@@ -1828,6 +1828,24 @@ TOML_START
 				}
 			}
 
+			template <typename T, typename N>
+			[[nodiscard]] static decltype(auto) do_ref(N&& n) noexcept
+			{
+				using type = impl::unwrapped<T>;
+				static_assert(
+					impl::is_value_or_node<type>,
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
+				);
+				TOML_ASSERT(
+					n.template is<T>()
+					&& "template type argument T provided to toml::node::ref() didn't match the node's actual type"
+				);
+				if constexpr (impl::is_value<type>)
+					return std::forward<N>(n).template ref_cast<type>().get();
+				else
+					return std::forward<N>(n).template ref_cast<type>();
+			}
+
 		public:
 
 			template <typename FUNC>
@@ -1847,6 +1865,24 @@ TOML_START
 			{
 				return do_visit(*this, std::forward<FUNC>(visitor));
 			}
+
+			template <typename T>
+			[[nodiscard]] impl::unwrapped<T>& ref() & noexcept
+			{
+				return do_ref<T>(*this);
+			}
+
+			template <typename T>
+			[[nodiscard]] impl::unwrapped<T>&& ref() && noexcept
+			{
+				return do_ref<T>(std::move(*this));
+			}
+
+			template <typename T>
+			[[nodiscard]] const impl::unwrapped<T>& ref() const& noexcept
+			{
+				return do_ref<T>(*this);
+			}
 	};
 }
 TOML_END
@@ -2996,18 +3032,21 @@ TOML_START
 			friend class toml::table;
 			template <typename U> friend class toml::node_view;
 
-			viewed_type* node_;
+			mutable viewed_type* node_;
 
 			TOML_NODISCARD_CTOR
 			node_view(viewed_type* node) noexcept
 				: node_{ node }
 			{}
 
+			template <typename FUNC>
+			static constexpr bool visit_is_nothrow
+				= noexcept(std::declval<viewed_type*>()->visit(std::declval<FUNC&&>()));
+
 		public:
 
 			[[nodiscard]] explicit operator bool() const noexcept { return node_ != nullptr; }
-			[[nodiscard]] viewed_type* get() noexcept { return node_; }
-			[[nodiscard]] const viewed_type* get() const noexcept { return node_; }
+			[[nodiscard]] viewed_type* get() const noexcept { return node_; }
 
 			[[nodiscard]] node_type type() const noexcept { return node_ ? node_->type() : node_type::none; }
 			[[nodiscard]] bool is_table() const noexcept { return node_ && node_->is_table(); }
@@ -3032,19 +3071,7 @@ TOML_START
 
 			template <typename U>
 			[[nodiscard]]
-			auto as() noexcept
-			{
-				static_assert(
-					impl::is_value_or_node<impl::unwrapped<U>>,
-					"Template type parameter must be one of the basic value types, a toml::table, or a toml::array"
-				);
-
-				return node_ ? node_->template as<U>() : nullptr;
-			}
-
-			template <typename U>
-			[[nodiscard]]
-			const impl::node_of<U>* as() const noexcept
+			auto as() const noexcept
 			{
 				static_assert(
 					impl::is_value_or_node<impl::unwrapped<U>>,
@@ -3054,24 +3081,15 @@ TOML_START
 				return node_ ? node_->template as<U>() : nullptr;
 			}
 
-			[[nodiscard]] auto as_table() noexcept { return as<table>(); }
-			[[nodiscard]] auto as_array() noexcept { return as<array>(); }
-			[[nodiscard]] auto as_string() noexcept { return as<string>(); }
-			[[nodiscard]] auto as_integer() noexcept { return as<int64_t>(); }
-			[[nodiscard]] auto as_floating_point() noexcept { return as<double>(); }
-			[[nodiscard]] auto as_boolean() noexcept { return as<bool>(); }
-			[[nodiscard]] auto as_date() noexcept { return as<date>(); }
-			[[nodiscard]] auto as_time() noexcept { return as<time>(); }
-			[[nodiscard]] auto as_date_time() noexcept { return as<date_time>(); }
-			[[nodiscard]] const table* as_table() const noexcept { return as<table>(); }
-			[[nodiscard]] const array* as_array() const noexcept { return as<array>(); }
-			[[nodiscard]] const toml::value<string>* as_string() const noexcept { return as<string>(); }
-			[[nodiscard]] const toml::value<int64_t>* as_integer() const noexcept { return as<int64_t>(); }
-			[[nodiscard]] const toml::value<double>* as_floating_point() const noexcept { return as<double>(); }
-			[[nodiscard]] const toml::value<bool>* as_boolean() const noexcept { return as<bool>(); }
-			[[nodiscard]] const toml::value<date>* as_date() const noexcept { return as<date>(); }
-			[[nodiscard]] const toml::value<time>* as_time() const noexcept { return as<time>(); }
-			[[nodiscard]] const toml::value<date_time>* as_date_time() const noexcept { return as<date_time>(); }
+			[[nodiscard]] auto as_table() const noexcept { return as<table>(); }
+			[[nodiscard]] auto as_array() const noexcept { return as<array>(); }
+			[[nodiscard]] auto as_string() const noexcept { return as<string>(); }
+			[[nodiscard]] auto as_integer() const noexcept { return as<int64_t>(); }
+			[[nodiscard]] auto as_floating_point() const noexcept { return as<double>(); }
+			[[nodiscard]] auto as_boolean() const noexcept { return as<bool>(); }
+			[[nodiscard]] auto as_date() const noexcept { return as<date>(); }
+			[[nodiscard]] auto as_time() const noexcept { return as<time>(); }
+			[[nodiscard]] auto as_date_time() const noexcept { return as<date_time>(); }
 
 			template <typename U>
 			[[nodiscard]] optional<U> value() const noexcept
@@ -3090,37 +3108,30 @@ TOML_START
 				return return_type{ std::forward<U>(default_value) };
 			}
 
-		private:
-
-			template <typename N, typename FUNC>
-			static decltype(auto) do_visit(N* node, FUNC&& visitor)
-				TOML_MAY_THROW_UNLESS(noexcept(std::declval<N*>()->visit(std::declval<FUNC&&>())))
+			template <typename FUNC>
+			decltype(auto) visit(FUNC&& visitor) const
+				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&>)
 			{
-				using return_type = decltype(node->visit(std::forward<FUNC>(visitor)));
-				if (node)
-					return node->visit(std::forward<FUNC>(visitor));
+				using return_type = decltype(node_->visit(std::forward<FUNC>(visitor)));
+				if (node_)
+					return node_->visit(std::forward<FUNC>(visitor));
 				if constexpr (!std::is_void_v<return_type>)
 					return return_type{};
 			}
 
-			template <typename FUNC, typename N>
-			static constexpr bool visit_is_nothrow =
-				noexcept(do_visit(std::declval<N*>(), std::declval<FUNC&&>()));
-
-		public:
-
-			template <typename FUNC>
-			decltype(auto) visit(FUNC&& visitor)
-				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, viewed_type>)
-			{
-				return do_visit(node_, std::forward<FUNC>(visitor));
-			}
-
-			template <typename FUNC>
-			decltype(auto) visit(FUNC&& visitor) const
-				TOML_MAY_THROW_UNLESS(visit_is_nothrow<FUNC&&, const viewed_type>)
+			template <typename U>
+			[[nodiscard]] decltype(auto) ref() const noexcept
 			{
-				return do_visit(node_, std::forward<FUNC>(visitor));
+				using type = impl::unwrapped<U>;
+				static_assert(
+					impl::is_value_or_node<type>,
+					"Template type parameter must be one of the TOML value types, a toml::table, or a toml::array"
+				);
+				TOML_ASSERT(
+					node_
+					&& "toml::node_view::ref() called on a node_view that did not reference a node"
+				);
+				return node_->template ref<type>();
 			}
 
 			[[nodiscard]] friend bool operator == (const node_view& lhs, const table& rhs) noexcept
@@ -3178,28 +3189,14 @@ TOML_START
 			}
 			TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const std::vector<U>&, template <typename U>)
 
-			[[nodiscard]] node_view operator[] (string_view key) noexcept
-			{
-				if (auto tbl = this->as_table())
-					return { tbl->get(key) };
-				return { nullptr };
-			}
-
-			[[nodiscard]] node_view<const viewed_type> operator[] (string_view key) const noexcept
+			[[nodiscard]] node_view operator[] (string_view key) const noexcept
 			{
 				if (auto tbl = this->as_table())
 					return { tbl->get(key) };
 				return { nullptr };
 			}
 
-			[[nodiscard]] node_view operator[] (size_t index) noexcept
-			{
-				if (auto arr = this->as_array())
-					return { arr->get(index) };
-				return { nullptr };
-			}
-
-			[[nodiscard]] node_view<const viewed_type> operator[] (size_t index) const noexcept
+			[[nodiscard]] node_view operator[] (size_t index) const noexcept
 			{
 				if (auto arr = this->as_array())
 					return { arr->get(index) };