forward_declarations.hpp

Go to the documentation of this file.

//# This file is a part of toml++ and is subject to the the terms of the MIT license.
//# Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
//# See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
// SPDX-License-Identifier: MIT
#pragma once
 
#include "std_string.hpp"
#include "std_new.hpp"
TOML_DISABLE_WARNINGS;
#include <cstdint>
#include <cstddef>
#include <cstring>
#include <cfloat>
#include <climits>
#include <cmath>
#include <limits>
#include <memory>
#include <iosfwd>
#include <type_traits>
TOML_ENABLE_WARNINGS;
#include "header_start.hpp"
 
//#---------------------------------------------------------------------------------------------------------------------
//# ENVIRONMENT GROUND-TRUTHS
//#---------------------------------------------------------------------------------------------------------------------
 
#ifndef TOML_DISABLE_ENVIRONMENT_CHECKS
#define TOML_ENV_MESSAGE                                                                                               \
    "If you're seeing this error it's because you're building toml++ for an environment that doesn't conform to "      \
    "one of the 'ground truths' assumed by the library. Essentially this just means that I don't have the "            \
    "resources to test on more platforms, but I wish I did! You can try disabling the checks by defining "             \
    "TOML_DISABLE_ENVIRONMENT_CHECKS, but your mileage may vary. Please consider filing an issue at "                  \
    "https://github.com/marzer/tomlplusplus/issues to help me improve support for your target environment. "           \
    "Thanks!"
 
static_assert(CHAR_BIT == 8, TOML_ENV_MESSAGE);
#ifdef FLT_RADIX
static_assert(FLT_RADIX == 2, TOML_ENV_MESSAGE);
#endif
static_assert('A' == 65, TOML_ENV_MESSAGE);
static_assert(sizeof(double) == 8, TOML_ENV_MESSAGE);
static_assert(std::numeric_limits<double>::is_iec559, TOML_ENV_MESSAGE);
static_assert(std::numeric_limits<double>::digits == 53, TOML_ENV_MESSAGE);
static_assert(std::numeric_limits<double>::digits10 == 15, TOML_ENV_MESSAGE);
static_assert(std::numeric_limits<double>::radix == 2, TOML_ENV_MESSAGE);
 
#undef TOML_ENV_MESSAGE
#endif // !TOML_DISABLE_ENVIRONMENT_CHECKS
 
 
//#---------------------------------------------------------------------------------------------------------------------
//# UNDOCUMENTED TYPEDEFS AND FORWARD DECLARATIONS
//#---------------------------------------------------------------------------------------------------------------------
// undocumented forward declarations are hidden from doxygen because they fuck it up =/
 
namespace toml // non-abi namespace; this is not an error
{
    using ::std::size_t;
    using ::std::intptr_t;
    using ::std::uintptr_t;
    using ::std::ptrdiff_t;
    using ::std::nullptr_t;
    using ::std::int8_t;
    using ::std::int16_t;
    using ::std::int32_t;
    using ::std::int64_t;
    using ::std::uint8_t;
    using ::std::uint16_t;
    using ::std::uint32_t;
    using ::std::uint64_t;
    using ::std::uint_least32_t;
    using ::std::uint_least64_t;
}
 
TOML_NAMESPACE_START
{
    struct date;
    struct time;
    struct time_offset;
 
    TOML_ABI_NAMESPACE_BOOL(TOML_HAS_CUSTOM_OPTIONAL_TYPE, custopt, stdopt);
    struct date_time;
    TOML_ABI_NAMESPACE_END;
 
    struct source_position;
    struct source_region;
 
    class node;
    template <typename>
    class node_view;
 
    class key;
    class array;
    class table;
    template <typename>
    class value;
 
    class path;
 
    class toml_formatter;
    class json_formatter;
    class yaml_formatter;
 
    TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, ex, noex);
#if TOML_EXCEPTIONS
    using parse_result = table;
#else
    class parse_result;
#endif
    TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
}
TOML_NAMESPACE_END;
 
TOML_IMPL_NAMESPACE_START
{
    using node_ptr = std::unique_ptr<node>;
 
    TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, impl_ex, impl_noex);
    class parser;
    TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
 
    // clang-format off
 
    inline constexpr std::string_view control_char_escapes[] =
    {
        "\\u0000"sv,
        "\\u0001"sv,
        "\\u0002"sv,
        "\\u0003"sv,
        "\\u0004"sv,
        "\\u0005"sv,
        "\\u0006"sv,
        "\\u0007"sv,
        "\\b"sv,
        "\\t"sv,
        "\\n"sv,
        "\\u000B"sv,
        "\\f"sv,
        "\\r"sv,
        "\\u000E"sv,
        "\\u000F"sv,
        "\\u0010"sv,
        "\\u0011"sv,
        "\\u0012"sv,
        "\\u0013"sv,
        "\\u0014"sv,
        "\\u0015"sv,
        "\\u0016"sv,
        "\\u0017"sv,
        "\\u0018"sv,
        "\\u0019"sv,
        "\\u001A"sv,
        "\\u001B"sv,
        "\\u001C"sv,
        "\\u001D"sv,
        "\\u001E"sv,
        "\\u001F"sv,
    };
 
    inline constexpr std::string_view node_type_friendly_names[] =
    {
        "none"sv,
        "table"sv,
        "array"sv,
        "string"sv,
        "integer"sv,
        "floating-point"sv,
        "boolean"sv,
        "date"sv,
        "time"sv,
        "date-time"sv
    };
 
    // clang-format on
}
TOML_IMPL_NAMESPACE_END;
 
#if TOML_ABI_NAMESPACES
#if TOML_EXCEPTIONS
#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_ex::parser
#else
#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_noex::parser
#endif
#else
#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::parser
#endif
 
 
//#---------------------------------------------------------------------------------------------------------------------
//# DOCUMENTED TYPEDEFS AND FORWARD DECLARATIONS
//#---------------------------------------------------------------------------------------------------------------------
 
namespace toml
{
}
 
TOML_NAMESPACE_START // abi namespace
{
    inline namespace literals
    {
    }
 
    enum class TOML_CLOSED_ENUM node_type : uint8_t
    {
        none,           
        table,          
        array,          
        string,         
        integer,        
        floating_point, 
        boolean,        
        date,           
        time,           
        date_time       
    };
 
    template <typename Char>
    inline std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& lhs, node_type rhs)
    {
        const auto str   = impl::node_type_friendly_names[static_cast<std::underlying_type_t<node_type>>(rhs)];
        using str_char_t = decltype(str)::value_type;
        if constexpr (std::is_same_v<Char, str_char_t>)
            return lhs << str;
        else
        {
            if constexpr (sizeof(Char) == sizeof(str_char_t))
                return lhs << std::basic_string_view<Char>{ reinterpret_cast<const Char*>(str.data()), str.length() };
            else
                return lhs << str.data();
        }
    }
 
    enum class TOML_OPEN_FLAGS_ENUM value_flags : uint16_t // being an "OPEN" flags enum is not an error
    {
        none,
 
        format_as_binary = 1,
 
        format_as_octal = 2,
 
        format_as_hexadecimal = 3,
    };
    TOML_MAKE_FLAGS(value_flags);
 
    inline constexpr value_flags preserve_source_value_flags =
        POXY_IMPLEMENTATION_DETAIL(value_flags{ static_cast<std::underlying_type_t<value_flags>>(-1) });
 
    enum class TOML_CLOSED_FLAGS_ENUM format_flags : uint64_t
    {
        none,
 
        quote_dates_and_times = (1ull << 0),
 
        quote_infinities_and_nans = (1ull << 1),
 
        allow_literal_strings = (1ull << 2),
 
        allow_multi_line_strings = (1ull << 3),
 
        allow_real_tabs_in_strings = (1ull << 4),
 
        allow_unicode_strings = (1ull << 5),
 
        allow_binary_integers = (1ull << 6),
 
        allow_octal_integers = (1ull << 7),
 
        allow_hexadecimal_integers = (1ull << 8),
 
        indent_sub_tables = (1ull << 9),
 
        indent_array_elements = (1ull << 10),
 
        indentation = indent_sub_tables | indent_array_elements,
 
        relaxed_float_precision = (1ull << 11),
 
        terse_key_value_pairs = (1ull << 12),
    };
    TOML_MAKE_FLAGS(format_flags);
 
    template <typename T>
    struct TOML_TRIVIAL_ABI inserter
    {
        static_assert(std::is_reference_v<T>);
 
        T value;
    };
    template <typename T>
    inserter(T&&) -> inserter<T&&>;
    template <typename T>
    inserter(T&) -> inserter<T&>;
 
    using default_formatter = toml_formatter;
}
TOML_NAMESPACE_END;
 
//#---------------------------------------------------------------------------------------------------------------------
//# METAFUNCTIONS & TYPE TRAITS
//#---------------------------------------------------------------------------------------------------------------------
TOML_IMPL_NAMESPACE_START
{
    template <typename T>
    using remove_cvref = std::remove_cv_t<std::remove_reference_t<T>>;
 
    template <typename... T>
    using common_signed_type = std::common_type_t<std::make_signed_t<T>...>;
 
    template <typename T, typename... U>
    inline constexpr bool is_one_of = (false || ... || std::is_same_v<T, U>);
 
    template <typename... T>
    inline constexpr bool all_integral = (std::is_integral_v<T> && ...);
 
    template <typename T>
    inline constexpr bool is_cvref = std::is_reference_v<T> || std::is_const_v<T> || std::is_volatile_v<T>;
 
    template <typename T>
    inline constexpr bool is_wide_string =
        is_one_of<std::decay_t<T>, const wchar_t*, wchar_t*, std::wstring_view, std::wstring>;
 
    template <typename T>
    inline constexpr bool value_retrieval_is_nothrow = !std::is_same_v<remove_cvref<T>, std::string>
#if TOML_HAS_CHAR8
                                                    && !std::is_same_v<remove_cvref<T>, std::u8string>
#endif
 
                                                    && !is_wide_string<T>;
 
    template <typename, typename>
    struct copy_ref_;
    template <typename Dest, typename Src>
    using copy_ref = typename copy_ref_<Dest, Src>::type;
 
    template <typename Dest, typename Src>
    struct copy_ref_
    {
        using type = Dest;
    };
 
    template <typename Dest, typename Src>
    struct copy_ref_<Dest, Src&>
    {
        using type = std::add_lvalue_reference_t<Dest>;
    };
 
    template <typename Dest, typename Src>
    struct copy_ref_<Dest, Src&&>
    {
        using type = std::add_rvalue_reference_t<Dest>;
    };
 
    template <typename, typename>
    struct copy_cv_;
    template <typename Dest, typename Src>
    using copy_cv = typename copy_cv_<Dest, Src>::type;
 
    template <typename Dest, typename Src>
    struct copy_cv_
    {
        using type = Dest;
    };
 
    template <typename Dest, typename Src>
    struct copy_cv_<Dest, const Src>
    {
        using type = std::add_const_t<Dest>;
    };
 
    template <typename Dest, typename Src>
    struct copy_cv_<Dest, volatile Src>
    {
        using type = std::add_volatile_t<Dest>;
    };
 
    template <typename Dest, typename Src>
    struct copy_cv_<Dest, const volatile Src>
    {
        using type = std::add_cv_t<Dest>;
    };
 
    template <typename Dest, typename Src>
    using copy_cvref =
        copy_ref<copy_ref<copy_cv<std::remove_reference_t<Dest>, std::remove_reference_t<Src>>, Dest>, Src>;
 
    template <typename...>
    inline constexpr bool always_false = false;
 
    template <typename T, typename... U>
    inline constexpr bool first_is_same = false;
    template <typename T, typename... U>
    inline constexpr bool first_is_same<T, T, U...> = true;
 
    template <typename T, bool = std::is_enum_v<T>>
    struct underlying_type_
    {
        using type = std::underlying_type_t<T>;
    };
    template <typename T>
    struct underlying_type_<T, false>
    {
        using type = T;
    };
    template <typename T>
    using underlying_type = typename underlying_type_<T>::type;
 
    // general value traits
    // (as they relate to their equivalent native TOML type)
    struct default_value_traits
    {
        using native_type                                         = void;
        static constexpr bool is_native                           = false;
        static constexpr bool is_losslessly_convertible_to_native = false;
        static constexpr bool can_represent_native                = false;
        static constexpr bool can_partially_represent_native      = false;
        static constexpr auto type                                = node_type::none;
    };
 
    template <typename T>
    struct value_traits;
 
    template <typename T, bool = std::is_enum_v<T>>
    struct value_traits_base_selector
    {
        static_assert(!is_cvref<T>);
 
        using type = default_value_traits;
    };
    template <typename T>
    struct value_traits_base_selector<T, true>
    {
        static_assert(!is_cvref<T>);
 
        using type = value_traits<underlying_type<T>>;
    };
 
    template <typename T>
    struct value_traits : value_traits_base_selector<T>::type
    {};
    template <typename T>
    struct value_traits<const T> : value_traits<T>
    {};
    template <typename T>
    struct value_traits<volatile T> : value_traits<T>
    {};
    template <typename T>
    struct value_traits<const volatile T> : value_traits<T>
    {};
    template <typename T>
    struct value_traits<T&> : value_traits<T>
    {};
    template <typename T>
    struct value_traits<T&&> : value_traits<T>
    {};
 
    // integer value_traits specializations - standard types
    template <typename T>
    struct integer_limits
    {
        static constexpr T min = T{ (std::numeric_limits<underlying_type<T>>::min)() };
        static constexpr T max = T{ (std::numeric_limits<underlying_type<T>>::max)() };
    };
    template <typename T>
    struct integer_traits_base : integer_limits<T>
    {
        using native_type               = int64_t;
        static constexpr bool is_native = std::is_same_v<underlying_type<T>, native_type>;
        static constexpr bool is_signed = static_cast<underlying_type<T>>(-1) < underlying_type<T>{};
        static constexpr auto type      = node_type::integer;
        static constexpr bool can_partially_represent_native = true;
    };
    template <typename T>
    struct unsigned_integer_traits : integer_traits_base<T>
    {
        static constexpr bool is_losslessly_convertible_to_native =
            integer_limits<underlying_type<T>>::max <= 9223372036854775807ULL;
        static constexpr bool can_represent_native = false;
    };
    template <typename T>
    struct signed_integer_traits : integer_traits_base<T>
    {
        using native_type = int64_t;
        static constexpr bool is_losslessly_convertible_to_native =
            integer_limits<underlying_type<T>>::min >= (-9223372036854775807LL - 1LL)
            && integer_limits<underlying_type<T>>::max <= 9223372036854775807LL;
        static constexpr bool can_represent_native =
            integer_limits<underlying_type<T>>::min <= (-9223372036854775807LL - 1LL)
            && integer_limits<underlying_type<T>>::max >= 9223372036854775807LL;
    };
    template <typename T, bool S = integer_traits_base<T>::is_signed>
    struct integer_traits : signed_integer_traits<T>
    {};
    template <typename T>
    struct integer_traits<T, false> : unsigned_integer_traits<T>
    {};
    template <>
    struct value_traits<signed char> : integer_traits<signed char>
    {};
    template <>
    struct value_traits<unsigned char> : integer_traits<unsigned char>
    {};
    template <>
    struct value_traits<signed short> : integer_traits<signed short>
    {};
    template <>
    struct value_traits<unsigned short> : integer_traits<unsigned short>
    {};
    template <>
    struct value_traits<signed int> : integer_traits<signed int>
    {};
    template <>
    struct value_traits<unsigned int> : integer_traits<unsigned int>
    {};
    template <>
    struct value_traits<signed long> : integer_traits<signed long>
    {};
    template <>
    struct value_traits<unsigned long> : integer_traits<unsigned long>
    {};
    template <>
    struct value_traits<signed long long> : integer_traits<signed long long>
    {};
    template <>
    struct value_traits<unsigned long long> : integer_traits<unsigned long long>
    {};
    static_assert(value_traits<int64_t>::is_native);
    static_assert(value_traits<int64_t>::is_signed);
    static_assert(value_traits<int64_t>::is_losslessly_convertible_to_native);
    static_assert(value_traits<int64_t>::can_represent_native);
    static_assert(value_traits<int64_t>::can_partially_represent_native);
 
    // integer value_traits specializations - non-standard types
#ifdef TOML_INT128
    template <>
    struct integer_limits<TOML_INT128>
    {
        static constexpr TOML_INT128 max =
            static_cast<TOML_INT128>((TOML_UINT128{ 1u } << ((__SIZEOF_INT128__ * CHAR_BIT) - 1)) - 1);
        static constexpr TOML_INT128 min = -max - TOML_INT128{ 1 };
    };
    template <>
    struct integer_limits<TOML_UINT128>
    {
        static constexpr TOML_UINT128 min = TOML_UINT128{};
        static constexpr TOML_UINT128 max = (2u * static_cast<TOML_UINT128>(integer_limits<TOML_INT128>::max)) + 1u;
    };
    template <>
    struct value_traits<TOML_INT128> : integer_traits<TOML_INT128>
    {};
    template <>
    struct value_traits<TOML_UINT128> : integer_traits<TOML_UINT128>
    {};
#endif
#ifdef TOML_SMALL_INT_TYPE
    template <>
    struct value_traits<TOML_SMALL_INT_TYPE> : signed_integer_traits<TOML_SMALL_INT_TYPE>
    {};
#endif
 
    // floating-point traits base
    template <typename T, int MantissaDigits, int DecimalDigits>
    struct float_traits_base
    {
        static constexpr auto type      = node_type::floating_point;
        using native_type               = double;
        static constexpr bool is_native = std::is_same_v<T, native_type>;
        static constexpr bool is_signed = true;
 
        static constexpr int bits     = static_cast<int>(sizeof(T) * CHAR_BIT);
        static constexpr int digits   = MantissaDigits;
        static constexpr int digits10 = DecimalDigits;
 
        static constexpr bool is_losslessly_convertible_to_native = bits <= 64      //
                                                                 && digits <= 53    // DBL_MANT_DIG
                                                                 && digits10 <= 15; // DBL_DIG
 
        static constexpr bool can_represent_native = digits >= 53    // DBL_MANT_DIG
                                                  && digits10 >= 15; // DBL_DIG
 
        static constexpr bool can_partially_represent_native = digits > 0 && digits10 > 0;
    };
    template <typename T>
    struct float_traits : float_traits_base<T, std::numeric_limits<T>::digits, std::numeric_limits<T>::digits10>
    {};
#if TOML_ENABLE_FLOAT16
    template <>
    struct float_traits<_Float16> : float_traits_base<_Float16, __FLT16_MANT_DIG__, __FLT16_DIG__>
    {};
#endif
#ifdef TOML_FLOAT128
    template <>
    struct float_traits<TOML_FLOAT128> : float_traits_base<TOML_FLOAT128, __FLT128_MANT_DIG__, __FLT128_DIG__>
    {};
#endif
 
    // floating-point traits
    template <>
    struct value_traits<float> : float_traits<float>
    {};
    template <>
    struct value_traits<double> : float_traits<double>
    {};
    template <>
    struct value_traits<long double> : float_traits<long double>
    {};
#if TOML_ENABLE_FLOAT16
    template <>
    struct value_traits<_Float16> : float_traits<_Float16>
    {};
#endif
#ifdef TOML_FLOAT128
    template <>
    struct value_traits<TOML_FLOAT128> : float_traits<TOML_FLOAT128>
    {};
#endif
#ifdef TOML_SMALL_FLOAT_TYPE
    template <>
    struct value_traits<TOML_SMALL_FLOAT_TYPE> : float_traits<TOML_SMALL_FLOAT_TYPE>
    {};
#endif
    static_assert(value_traits<double>::is_native);
    static_assert(value_traits<double>::is_losslessly_convertible_to_native);
    static_assert(value_traits<double>::can_represent_native);
    static_assert(value_traits<double>::can_partially_represent_native);
 
    // string value_traits specializations - char-based strings
    template <typename T>
    struct string_traits
    {
        using native_type                                         = std::string;
        static constexpr bool is_native                           = std::is_same_v<T, native_type>;
        static constexpr bool is_losslessly_convertible_to_native = true;
        static constexpr bool can_represent_native =
            !std::is_array_v<T> && (!std::is_pointer_v<T> || std::is_const_v<std::remove_pointer_t<T>>);
        static constexpr bool can_partially_represent_native = can_represent_native;
        static constexpr auto type                           = node_type::string;
    };
    template <>
    struct value_traits<std::string> : string_traits<std::string>
    {};
    template <>
    struct value_traits<std::string_view> : string_traits<std::string_view>
    {};
    template <>
    struct value_traits<const char*> : string_traits<const char*>
    {};
    template <size_t N>
    struct value_traits<const char[N]> : string_traits<const char[N]>
    {};
    template <>
    struct value_traits<char*> : string_traits<char*>
    {};
    template <size_t N>
    struct value_traits<char[N]> : string_traits<char[N]>
    {};
 
    // string value_traits specializations - char8_t-based strings
#if TOML_HAS_CHAR8
    template <>
    struct value_traits<std::u8string> : string_traits<std::u8string>
    {};
    template <>
    struct value_traits<std::u8string_view> : string_traits<std::u8string_view>
    {};
    template <>
    struct value_traits<const char8_t*> : string_traits<const char8_t*>
    {};
    template <size_t N>
    struct value_traits<const char8_t[N]> : string_traits<const char8_t[N]>
    {};
    template <>
    struct value_traits<char8_t*> : string_traits<char8_t*>
    {};
    template <size_t N>
    struct value_traits<char8_t[N]> : string_traits<char8_t[N]>
    {};
#endif
 
    // string value_traits specializations - wchar_t-based strings on Windows
#if TOML_ENABLE_WINDOWS_COMPAT
    template <typename T>
    struct wstring_traits
    {
        using native_type                                         = std::string;
        static constexpr bool is_native                           = false;
        static constexpr bool is_losslessly_convertible_to_native = true;                            // narrow
        static constexpr bool can_represent_native                = std::is_same_v<T, std::wstring>; // widen
        static constexpr bool can_partially_represent_native      = can_represent_native;
        static constexpr auto type                                = node_type::string;
    };
    template <>
    struct value_traits<std::wstring> : wstring_traits<std::wstring>
    {};
    template <>
    struct value_traits<std::wstring_view> : wstring_traits<std::wstring_view>
    {};
    template <>
    struct value_traits<const wchar_t*> : wstring_traits<const wchar_t*>
    {};
    template <size_t N>
    struct value_traits<const wchar_t[N]> : wstring_traits<const wchar_t[N]>
    {};
    template <>
    struct value_traits<wchar_t*> : wstring_traits<wchar_t*>
    {};
    template <size_t N>
    struct value_traits<wchar_t[N]> : wstring_traits<wchar_t[N]>
    {};
#endif
 
    // other 'native' value_traits specializations
    template <typename T, node_type NodeType>
    struct native_value_traits
    {
        using native_type                                         = T;
        static constexpr bool is_native                           = true;
        static constexpr bool is_losslessly_convertible_to_native = true;
        static constexpr bool can_represent_native                = true;
        static constexpr bool can_partially_represent_native      = true;
        static constexpr auto type                                = NodeType;
    };
    template <>
    struct value_traits<bool> : native_value_traits<bool, node_type::boolean>
    {};
    template <>
    struct value_traits<date> : native_value_traits<date, node_type::date>
    {};
    template <>
    struct value_traits<time> : native_value_traits<time, node_type::time>
    {};
    template <>
    struct value_traits<date_time> : native_value_traits<date_time, node_type::date_time>
    {};
 
    // native value category queries
    template <typename T>
    using native_type_of = typename value_traits<T>::native_type;
    template <typename T>
    inline constexpr bool is_native = value_traits<T>::is_native;
    template <typename T>
    inline constexpr bool can_represent_native = value_traits<T>::can_represent_native;
    template <typename T>
    inline constexpr bool can_partially_represent_native = value_traits<T>::can_partially_represent_native;
    template <typename T>
    inline constexpr bool is_losslessly_convertible_to_native = value_traits<T>::is_losslessly_convertible_to_native;
    template <typename T, typename... U>
    inline constexpr bool is_natively_one_of = is_one_of<native_type_of<T>, U...>;
 
    // native value types => nodes
    template <typename T>
    struct node_wrapper
    {
        using type = T;
    };
    template <typename T>
    struct node_wrapper<const T>
    {
        using type = std::add_const_t<typename node_wrapper<T>::type>;
    };
    template <typename T>
    struct node_wrapper<volatile T>
    {
        using type = std::add_volatile_t<typename node_wrapper<T>::type>;
    };
    template <typename T>
    struct node_wrapper<const volatile T>
    {
        using type = std::add_const_t<std::add_volatile_t<typename node_wrapper<T>::type>>;
    };
    template <>
    struct node_wrapper<std::string>
    {
        using type = value<std::string>;
    };
    template <>
    struct node_wrapper<int64_t>
    {
        using type = value<int64_t>;
    };
    template <>
    struct node_wrapper<double>
    {
        using type = value<double>;
    };
    template <>
    struct node_wrapper<bool>
    {
        using type = value<bool>;
    };
    template <>
    struct node_wrapper<date>
    {
        using type = value<date>;
    };
    template <>
    struct node_wrapper<time>
    {
        using type = value<time>;
    };
    template <>
    struct node_wrapper<date_time>
    {
        using type = value<date_time>;
    };
    template <typename T>
    using wrap_node = typename node_wrapper<std::remove_reference_t<T>>::type;
 
    // nodes => native value types
    template <typename T>
    struct node_unwrapper
    {
        using type = T;
    };
    template <typename T>
    struct node_unwrapper<value<T>>
    {
        using type = T;
    };
    template <typename T>
    struct node_unwrapper<const value<T>>
    {
        using type = std::add_const_t<T>;
    };
    template <typename T>
    struct node_unwrapper<volatile value<T>>
    {
        using type = std::add_volatile_t<T>;
    };
    template <typename T>
    struct node_unwrapper<const volatile value<T>>
    {
        using type = std::add_volatile_t<std::add_const_t<T>>;
    };
    template <typename T>
    using unwrap_node = typename node_unwrapper<std::remove_reference_t<T>>::type;
 
    template <typename T>
    struct node_type_getter
    {
        static constexpr auto value = value_traits<T>::type;
    };
    template <>
    struct node_type_getter<table>
    {
        static constexpr auto value = node_type::table;
    };
    template <>
    struct node_type_getter<array>
    {
        static constexpr auto value = node_type::array;
    };
    template <>
    struct node_type_getter<void>
    {
        static constexpr auto value = node_type::none;
    };
    template <typename T>
    inline constexpr node_type node_type_of = node_type_getter<unwrap_node<remove_cvref<T>>>::value;
 
    template <typename T, typename ConvertFrom>
    inline constexpr bool is_constructible_or_convertible = std::is_constructible_v<T, ConvertFrom> //
                                                         || std::is_convertible_v<ConvertFrom, T>;
}
TOML_IMPL_NAMESPACE_END;
 
TOML_NAMESPACE_START
{
    template <typename T>
    inline constexpr bool is_table = std::is_same_v<impl::remove_cvref<T>, table>;
 
    template <typename T>
    inline constexpr bool is_array = std::is_same_v<impl::remove_cvref<T>, array>;
 
    template <typename T>
    inline constexpr bool is_container = is_table<T> || is_array<T>;
 
    template <typename T>
    inline constexpr bool is_string = std::is_same_v<               //
        impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
        value<std::string>>;
 
    template <typename T>
    inline constexpr bool is_integer = std::is_same_v<              //
        impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
        value<int64_t>>;
 
    template <typename T>
    inline constexpr bool is_floating_point = std::is_same_v<       //
        impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
        value<double>>;
 
    template <typename T>
    inline constexpr bool is_number = is_integer<T> || is_floating_point<T>;
 
    template <typename T>
    inline constexpr bool is_boolean = std::is_same_v<              //
        impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
        value<bool>>;
 
    template <typename T>
    inline constexpr bool is_date = std::is_same_v<                 //
        impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
        value<date>>;
 
    template <typename T>
    inline constexpr bool is_time = std::is_same_v<                 //
        impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
        value<time>>;
 
    template <typename T>
    inline constexpr bool is_date_time = std::is_same_v<            //
        impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
        value<date_time>>;
 
    template <typename T>
    inline constexpr bool is_chronological = is_date<T> || is_time<T> || is_date_time<T>;
 
    template <typename T>
    inline constexpr bool is_value = is_string<T> || is_number<T> || is_boolean<T> || is_chronological<T>;
 
    template <typename T>
    inline constexpr bool is_node = std::is_same_v<toml::node, impl::remove_cvref<T>> //
                                 || std::is_base_of_v<toml::node, impl::remove_cvref<T>>;
 
    template <typename T>
    inline constexpr bool is_node_view = impl::is_one_of<impl::remove_cvref<T>, node_view<node>, node_view<const node>>;
}
TOML_NAMESPACE_END;
 
//#---------------------------------------------------------------------------------------------------------------------
//# INTERNAL HELPERS
//#---------------------------------------------------------------------------------------------------------------------
TOML_IMPL_NAMESPACE_START
{
    template <typename T>
    TOML_CONST_INLINE_GETTER
    constexpr std::underlying_type_t<T> unwrap_enum(T val) noexcept
    {
        return static_cast<std::underlying_type_t<T>>(val);
    }
 
    // Q: "why not use std::fpclassify?"
    // A: Because it gets broken by -ffast-math and friends
    enum class TOML_CLOSED_ENUM fp_class : unsigned
    {
        ok,
        neg_inf,
        pos_inf,
        nan
    };
 
    TOML_PURE_GETTER
    inline fp_class fpclassify(const double& val) noexcept
    {
        static_assert(sizeof(uint64_t) == sizeof(double));
 
        static constexpr uint64_t sign     = 0b1000000000000000000000000000000000000000000000000000000000000000ull;
        static constexpr uint64_t exponent = 0b0111111111110000000000000000000000000000000000000000000000000000ull;
        static constexpr uint64_t mantissa = 0b0000000000001111111111111111111111111111111111111111111111111111ull;
 
        uint64_t val_bits;
        std::memcpy(&val_bits, &val, sizeof(val));
        if ((val_bits & exponent) != exponent)
            return fp_class::ok;
        if ((val_bits & mantissa))
            return fp_class::nan;
        return (val_bits & sign) ? fp_class::neg_inf : fp_class::pos_inf;
    }
 
    // Q: "why not use std::find and std::min?"
    // A: Because <algorithm> is _huge_ and these would be the only things I used from it.
    //    I don't want to impose such a heavy compile-time burden on users.
 
    template <typename Iterator, typename T>
    TOML_PURE_GETTER
    inline auto find(Iterator start, Iterator end, const T& needle) noexcept //
        ->decltype(&(*start))
    {
        for (; start != end; start++)
            if (*start == needle)
                return &(*start);
        return nullptr;
    }
 
    template <typename T>
    TOML_PURE_INLINE_GETTER
    constexpr const T& min(const T& a, const T& b) noexcept //
    {
        return a < b ? a : b;
    }
}
TOML_IMPL_NAMESPACE_END;
 
#include "header_end.hpp"