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_new.hpp"
#include "std_string.hpp"
TOML_DISABLE_WARNINGS;
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <iosfwd>
#include <limits>
#include <memory>
#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::int16_t;
using ::std::int32_t;
using ::std::int64_t;
using ::std::int8_t;
using ::std::intptr_t;
using ::std::nullptr_t;
using ::std::ptrdiff_t;
using ::std::size_t;
using ::std::uint16_t;
using ::std::uint32_t;
using ::std::uint64_t;
using ::std::uint8_t;
using ::std::uint_least32_t;
using ::std::uint_least64_t;
using ::std::uintptr_t;
}  // namespace toml
 
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"