#include <cassert>
#include <new>
#include <string_view>
#include <string>
#include <optional>
#include <cstdint>
#include <cstddef>
#include <cstring>
#include <cfloat>
#include <climits>
#include <cmath>
#include <limits>
#include <memory>
#include <iosfwd>
#include <type_traits>
#include <vector>
#include <iterator>
#include <utility>
#include <initializer_list>
#include <map>
#include <ostream>
#include <sstream>
#include <iomanip>
#include <istream>
#include <fstream>

Include dependency graph for toml.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	inserter< T >
struct	copy_ref_< Dest, Src >
struct	copy_ref_< Dest, Src & >
struct	copy_ref_< Dest, Src && >
struct	copy_cv_< Dest, Src >
struct	copy_cv_< Dest, const Src >
struct	copy_cv_< Dest, volatile Src >
struct	copy_cv_< Dest, const volatile Src >
struct	underlying_type_< T, bool >
struct	underlying_type_< T, false >
struct	default_value_traits
struct	value_traits_base_selector< T, bool >
struct	value_traits_base_selector< T, true >
struct	value_traits< T >
struct	value_traits< const T >
struct	value_traits< volatile T >
struct	value_traits< const volatile T >
struct	value_traits< T & >
struct	value_traits< T && >
struct	integer_limits< T >
struct	integer_traits_base< T >
struct	unsigned_integer_traits< T >
struct	signed_integer_traits< T >
struct	integer_traits< T, S >
struct	integer_traits< T, false >
struct	value_traits< signed char >
struct	value_traits< unsigned char >
struct	value_traits< signed short >
struct	value_traits< unsigned short >
struct	value_traits< signed int >
struct	value_traits< unsigned int >
struct	value_traits< signed long >
struct	value_traits< unsigned long >
struct	value_traits< signed long long >
struct	value_traits< unsigned long long >
struct	float_traits_base< T, MantissaDigits, DecimalDigits >
struct	float_traits< T >
struct	value_traits< float >
struct	value_traits< double >
struct	value_traits< long double >
struct	string_traits< T >
struct	value_traits< std::string >
struct	value_traits< std::string_view >
struct	value_traits< const char * >
struct	value_traits< const char[N]>
struct	value_traits< char * >
struct	value_traits< char[N]>
struct	native_value_traits< T, NodeType >
struct	value_traits< bool >
struct	value_traits< date >
struct	value_traits< time >
struct	value_traits< date_time >
struct	node_wrapper< T >
struct	node_wrapper< const T >
struct	node_wrapper< volatile T >
struct	node_wrapper< const volatile T >
struct	node_wrapper< std::string >
struct	node_wrapper< int64_t >
struct	node_wrapper< double >
struct	node_wrapper< bool >
struct	node_wrapper< date >
struct	node_wrapper< time >
struct	node_wrapper< date_time >
struct	node_unwrapper< T >
struct	node_unwrapper< value< T > >
struct	node_unwrapper< const value< T > >
struct	node_unwrapper< volatile value< T > >
struct	node_unwrapper< const volatile value< T > >
struct	node_type_getter< T >
struct	node_type_getter< table >
struct	node_type_getter< array >
struct	node_type_getter< void >
struct	source_position
struct	source_region
struct	time
struct	time_offset
struct	date_time
class	path_component
class	path
struct	native_value_maker< T, T >
struct	value_variadic_ctor_allowed<... >
struct	value_variadic_ctor_allowed< value< T >, value< T >, Args... >
struct	inserted_type_of_< inserter< T >, false >
struct	inserted_type_of_< T, false >
struct	emplaced_type_of_< T >
struct	emplaced_type_of_< T >
struct	emplaced_type_of_< inserter< T > >
struct	array_init_elem
class	array
class	table_iterator< IsConst >
struct	table_init_pair
class	table
class	TOML_PARSE_ERROR_BASE
class	parse_result
struct	formatter_config
class	formatter
class	utf8_byte_stream< std::basic_string_view< Char > >
class	utf8_byte_stream< std::istream >
struct	utf8_codepoint
struct	utf8_reader_interface
class	utf8_reader< T >
class	utf8_buffered_reader
struct	parse_integer_traits< 2 >
struct	parse_integer_traits< 8 >
struct	parse_integer_traits< 10 >
struct	parse_integer_traits< 16 >
struct	escaped_codepoint
struct	error_builder
struct	parse_scope
struct	parse_key_buffer
struct	depth_counter_scope
struct	parsed_string
struct	table_vector_scope
class	parser

Namespaces
namespace	toml
namespace	literals

Macros
#define	INCLUDE_TOMLPLUSPLUS_H
#define	TOMLPLUSPLUS_H
#define	TOML_CPP __cplusplus
#define	TOML_CPP 0
#define	TOML_MAKE_VERSION(major, minor, patch)
#define	TOML_INTELLISENSE 0
#define	TOML_DOXYGEN 0
#define	TOML_CLANG 0
#define	TOML_ICC 0
#define	TOML_ICC_CL 0
#define	TOML_MSVC_LIKE 0
#define	TOML_MSVC 0
#define	TOML_GCC_LIKE 0
#define	TOML_GCC 0
#define	TOML_CUDA 0
#define	TOML_NVCC 0
#define	TOML_ARCH_ITANIUM 0
#define	TOML_ARCH_AMD64 0
#define	TOML_ARCH_X86 0
#define	TOML_ARCH_ARM32 0
#define	TOML_ARCH_ARM64 0
#define	TOML_ARCH_ARM 0
#define	TOML_ARCH_BITNESS 0
#define	TOML_ARCH_X64 0
#define	TOML_WINDOWS 0
#define	TOML_UNIX 0
#define	TOML_LINUX 0
#define	TOML_HAS_INCLUDE(header)
#define	TOML_HAS_BUILTIN(name)
#define	TOML_HAS_FEATURE(name)
#define	TOML_HAS_ATTR(attr)
#define	TOML_HAS_CPP_ATTR(attr)
#define	TOML_ATTR(...)
#define	TOML_DECLSPEC(...)
#define	TOML_COMPILER_HAS_EXCEPTIONS 0
#define	TOML_COMPILER_HAS_RTTI 0
#define	TOML_CONCAT_1(x, y)
#define	TOML_CONCAT(x, y)
#define	TOML_MAKE_STRING_1(s)
#define	TOML_MAKE_STRING(s)
#define	TOML_PRAGMA_CLANG(decl)
#define	TOML_PRAGMA_CLANG_GE_8(decl)
#define	TOML_PRAGMA_CLANG_GE_9(decl)
#define	TOML_PRAGMA_CLANG_GE_10(decl)
#define	TOML_PRAGMA_CLANG_GE_11(decl)
#define	TOML_PRAGMA_GCC(decl)
#define	TOML_PRAGMA_MSVC(...)
#define	TOML_PRAGMA_ICC(...)
#define	TOML_ALWAYS_INLINE inline
#define	TOML_NEVER_INLINE
#define	TOML_ABSTRACT_INTERFACE TOML_DECLSPEC(novtable)
#define	TOML_EMPTY_BASES TOML_DECLSPEC(empty_bases)
#define	TOML_TRIVIAL_ABI
#define	TOML_NODISCARD
#define	TOML_NODISCARD_CTOR
#define	TOML_PURE
#define	TOML_CONST
#define	TOML_INLINE_GETTER
#define	TOML_PURE_GETTER
#define	TOML_PURE_INLINE_GETTER
#define	TOML_CONST_GETTER
#define	TOML_CONST_INLINE_GETTER
#define	TOML_ASSUME(expr)
#define	TOML_UNREACHABLE static_cast<void>(0)
#define	TOML_LIKELY(...)
#define	TOML_LIKELY_CASE
#define	TOML_UNLIKELY(...)
#define	TOML_UNLIKELY_CASE
#define	TOML_FLAGS_ENUM
#define	TOML_OPEN_ENUM
#define	TOML_CLOSED_ENUM
#define	TOML_OPEN_FLAGS_ENUM TOML_OPEN_ENUM TOML_FLAGS_ENUM
#define	TOML_CLOSED_FLAGS_ENUM TOML_CLOSED_ENUM TOML_FLAGS_ENUM
#define	TOML_MAKE_FLAGS_2(T, op, linkage)
#define	TOML_MAKE_FLAGS_1(T, linkage)
#define	TOML_MAKE_FLAGS(T)
#define	TOML_UNUSED(...)
#define	TOML_DELETE_DEFAULTS(T)
#define	TOML_ASYMMETRICAL_EQUALITY_OPS(LHS, RHS, ...)
#define	TOML_EVAL_BOOL_1(T, F)
#define	TOML_EVAL_BOOL_0(T, F)
#define	POXY_IMPLEMENTATION_DETAIL(...)
#define	TOML_PUSH_WARNINGS static_assert(true)
#define	TOML_DISABLE_CODE_ANALYSIS_WARNINGS static_assert(true)
#define	TOML_DISABLE_SWITCH_WARNINGS static_assert(true)
#define	TOML_DISABLE_SUGGEST_ATTR_WARNINGS static_assert(true)
#define	TOML_DISABLE_SPAM_WARNINGS static_assert(true)
#define	TOML_DISABLE_ARITHMETIC_WARNINGS static_assert(true)
#define	TOML_POP_WARNINGS static_assert(true)
#define	TOML_DISABLE_WARNINGS static_assert(true)
#define	TOML_ENABLE_WARNINGS static_assert(true)
#define	TOML_SIMPLE_STATIC_ASSERT_MESSAGES 0
#define	TOML_SHARED_LIB 0
#define	TOML_HEADER_ONLY 1
#define	TOML_IMPLEMENTATION 1
#define	TOML_EXPORTED_CLASS
#define	TOML_EXPORTED_MEMBER_FUNCTION
#define	TOML_EXPORTED_STATIC_FUNCTION
#define	TOML_EXPORTED_FREE_FUNCTION
#define	TOML_ENABLE_UNRELEASED_FEATURES 0
#define	TOML_ENABLE_PARSER 1
#define	TOML_ENABLE_FORMATTERS 1
#define	TOML_ENABLE_SIMD 1
#define	TOML_ENABLE_WINDOWS_COMPAT 1
#define	TOML_ENABLE_WINDOWS_COMPAT 0
#define	TOML_INCLUDE_WINDOWS_H 0
#define	TOML_HAS_CUSTOM_OPTIONAL_TYPE 0
#define	TOML_EXCEPTIONS 0
#define	TOML_CALLCONV
#define	TOML_UNDEF_MACROS 1
#define	TOML_MAX_NESTED_VALUES 256
#define	TOML_LIFETIME_HOOKS 0
#define	TOML_ASSERT(expr)
#define	TOML_ASSERT_ASSUME(expr)
#define	TOML_ENABLE_FLOAT16 0
#define	TOML_INT_CHARCONV 1
#define	TOML_FLOAT_CHARCONV 1
#define	TOML_INT_CHARCONV 0
#define	TOML_FLOAT_CHARCONV 0
#define	TOML_REQUIRES(...)
#define	TOML_ENABLE_IF(...)
#define	TOML_CONSTRAINED_TEMPLATE(condition, ...)
#define	TOML_HIDDEN_CONSTRAINT(condition, ...)
#define	TOML_LIB_MAJOR 3
#define	TOML_LIB_MINOR 4
#define	TOML_LIB_PATCH 0
#define	TOML_LANG_MAJOR 1
#define	TOML_LANG_MINOR 0
#define	TOML_LANG_PATCH 0
#define	TOML_LIB_SINGLE_HEADER 1
#define	TOML_LANG_EFFECTIVE_VERSION TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)
#define	TOML_LANG_HIGHER_THAN(major, minor, patch)
#define	TOML_LANG_AT_LEAST(major, minor, patch)
#define	TOML_LANG_UNRELEASED TOML_LANG_HIGHER_THAN(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)
#define	TOML_ABI_NAMESPACES 1
#define	TOML_NAMESPACE_START namespace toml { inline namespace TOML_CONCAT(v, TOML_LIB_MAJOR)
#define	TOML_NAMESPACE_END } static_assert(true)
#define	TOML_NAMESPACE ::toml::TOML_CONCAT(v, TOML_LIB_MAJOR)
#define	TOML_ABI_NAMESPACE_START(name)
#define	TOML_ABI_NAMESPACE_BOOL(cond, T, F)
#define	TOML_ABI_NAMESPACE_END } static_assert(true)
#define	TOML_IMPL_NAMESPACE_START TOML_NAMESPACE_START { namespace impl
#define	TOML_IMPL_NAMESPACE_END } TOML_NAMESPACE_END
#define	TOML_ANON_NAMESPACE_START static_assert(TOML_IMPLEMENTATION); TOML_IMPL_NAMESPACE_START
#define	TOML_ANON_NAMESPACE_END TOML_IMPL_NAMESPACE_END
#define	TOML_ANON_NAMESPACE TOML_NAMESPACE::impl
#define	TOML_EXTERNAL_LINKAGE inline
#define	TOML_INTERNAL_LINKAGE inline
#define	TOML_SA_NEWLINE "\n\| "
#define	TOML_SA_LIST_SEP TOML_SA_NEWLINE " - "
#define	TOML_SA_LIST_BEG TOML_SA_LIST_SEP
#define	TOML_SA_LIST_END
#define	TOML_SA_LIST_NEW TOML_SA_NEWLINE TOML_SA_NEWLINE
#define	TOML_SA_LIST_NXT TOML_SA_LIST_NEW
#define	TOML_SA_NATIVE_VALUE_TYPE_LIST
#define	TOML_SA_NODE_TYPE_LIST
#define	TOML_SA_UNWRAPPED_NODE_TYPE_LIST
#define	TOML_LAUNDER(x)
#define	TOML_HAS_CHAR8 0
#define	TOML_ENV_MESSAGE
#define	TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_noex::parser
#define	TOML_NVCC_WORKAROUND = 0
#define	TOML_SA_VALUE_MESSAGE_WSTRING
#define	TOML_SA_VALUE_MESSAGE_U8STRING_VIEW
#define	TOML_SA_VALUE_MESSAGE_CONST_CHAR8
#define	TOML_SA_VALUE_EXACT_FUNC_MESSAGE(type_arg)
#define	TOML_SA_VALUE_FUNC_MESSAGE(type_arg)
#define	TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN 0
#define	TOML_PARSE_ERROR_BASE
#define	TOML_HAS_SSE2 0
#define	TOML_HAS_SSE4_1 0
#define	utf8_reader_error(...)
#define	utf8_reader_return_after_error(...)
#define	utf8_reader_error_check(...)
#define	TOML_OVERALIGNED alignas(32)
#define	utf8_buffered_reader_error_check(...)
#define	TOML_RETURNS_BY_THROWING
#define	push_parse_scope_2(scope, line)
#define	push_parse_scope_1(scope, line)
#define	push_parse_scope(scope)
#define	is_eof()
#define	assert_not_eof()
#define	return_if_eof(...)
#define	is_error()
#define	return_after_error(...)
#define	assert_not_error()
#define	return_if_error(...)
#define	return_if_error_or_eof(...)
#define	parse_error_break()
#define	set_error_and_return(ret, ...)
#define	set_error_and_return_default(...)
#define	set_error_and_return_if_eof(...)
#define	advance_and_return_if_error(...)
#define	advance_and_return_if_error_or_eof(...)
#define	TOML_PARSE_FILE_ERROR(msg, path)

Typedefs
using	default_formatter = toml_formatter
template<typename... T>
using	common_signed_type = std::common_type_t<std::make_signed_t<T>...>
template<typename Dest, typename Src>
using	copy_ref = typename copy_ref_<Dest, Src>::type
template<typename Dest, typename Src>
using	copy_cv = typename copy_cv_<Dest, Src>::type
template<typename Dest, typename Src>
using	copy_cvref
template<typename T>
using	underlying_type = typename underlying_type_<T>::type
template<typename T>
using	native_type_of = typename value_traits<T>::native_type
template<typename T>
using	wrap_node = typename node_wrapper<std::remove_reference_t<T>>::type
template<typename T>
using	unwrap_node = typename node_unwrapper<std::remove_reference_t<T>>::type
using	source_path_ptr = std::shared_ptr<const std::string>
template<typename... T>
using	emplaced_type_of = typename emplaced_type_of_<remove_cvref<T>...>::type
using	const_array_iterator
using	const_table_iterator

Functions
	TOML_ABI_NAMESPACE_BOOL (TOML_HAS_CUSTOM_OPTIONAL_TYPE, custopt, stdopt)
	TOML_ABI_NAMESPACE_BOOL (TOML_EXCEPTIONS, ex, noex)
	TOML_ABI_NAMESPACE_BOOL (TOML_EXCEPTIONS, impl_ex, impl_noex)
template<typename Char>
std::basic_ostream< Char > &	operator<< (std::basic_ostream< Char > &lhs, node_type rhs)
enum TOML_OPEN_FLAGS_ENUM	TOML_MAKE_FLAGS (value_flags)
enum TOML_CLOSED_FLAGS_ENUM	TOML_MAKE_FLAGS (format_flags)
template<typename T>
	inserter (T &&) -> inserter< T && >
template<typename T>
	inserter (T &) -> inserter< T & >
TOML_PURE_GETTER fp_class	fpclassify (const double &val) noexcept
template<typename Iterator, typename T>
TOML_PURE_GETTER auto	find (Iterator start, Iterator end, const T &needle) noexcept -> decltype(&(*start))
template<typename T>
TOML_PURE_INLINE_GETTER constexpr const T &	min (const T &a, const T &b) noexcept
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, std::string_view)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const std::string &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, char)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, signed char, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, signed short, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, signed int, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, signed long, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, signed long long, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, unsigned char, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, unsigned short, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, unsigned int, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, unsigned long, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, unsigned long long, value_flags={}, size_t min_digits=0)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, float, value_flags={}, bool relaxed_precision=false)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, double, value_flags={}, bool relaxed_precision=false)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, bool)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const toml::date &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const toml::time &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const toml::time_offset &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const toml::date_time &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const source_position &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const source_region &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const array &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const table &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const value< std::string > &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const value< int64_t > &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const value< double > &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const value< bool > &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const value< date > &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const value< time > &)
TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV	print_to_stream (std::ostream &, const value< date_time > &)
template<typename T, typename U>
void	print_to_stream_bookended (std::ostream &stream, const T &val, const U &bookend)
TOML_NODISCARD bool TOML_CALLCONV	parse_path (std::string_view, void *, parse_path_callback< std::string_view >, parse_path_callback< size_t >)
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION node_view< const node > TOML_CALLCONV	at_path (const node &root, std::string_view path) noexcept
TOML_NODISCARD TOML_ALWAYS_INLINE path	literals::operator""_tpath (const char *str, size_t len)
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION node_view< node > TOML_CALLCONV	at_path (node &root, const toml::path &path) noexcept
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION node_view< const node > TOML_CALLCONV	at_path (const node &root, const toml::path &path) noexcept
template<typename T>
	node_view (const T &) -> node_view< const node >
template<typename T>
	node_view (const T *) -> node_view< const node >
template<typename T>
	node_view (T &) -> node_view< node >
template<typename T>
	node_view (T *) -> node_view< node >
template<typename T>
TOML_CONST_GETTER optional< T >	node_integer_cast (int64_t val) noexcept
template<typename T>
	value (T) -> value< impl::native_type_of< impl::remove_cvref< T > > >
template<typename T>
	value (T, value_flags) -> value< impl::native_type_of< impl::remove_cvref< T > > >
template<typename T>
TOML_NODISCARD node_ptr	make_node (T &&val, value_flags flags=preserve_source_value_flags)
TOML_PURE_GETTER bool	is_ascii (const char *str, size_t len) noexcept
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION parse_result TOML_CALLCONV	parse (std::string_view doc, std::string_view source_path={})
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION parse_result TOML_CALLCONV	parse (std::string_view doc, std::string &&source_path)
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION parse_result TOML_CALLCONV	parse_file (std::string_view file_path)
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION parse_result TOML_CALLCONV	parse (std::istream &doc, std::string_view source_path={})
TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION parse_result TOML_CALLCONV	parse (std::istream &doc, std::string &&source_path)
	literals::TOML_ABI_NAMESPACE_BOOL (TOML_EXCEPTIONS, lit_ex, lit_noex)
TOML_NODISCARD TOML_ALWAYS_INLINE parse_result	literals::operator""_toml (const char *str, size_t len)
template<typename T>
TOML_INTERNAL_LINKAGE void	print_integer_to_stream (std::ostream &stream, T val, value_flags format={}, size_t min_digits=0)
template<typename T>
TOML_INTERNAL_LINKAGE void	print_floating_point_to_stream (std::ostream &stream, T val, value_flags format, bool relaxed_precision)
template<typename Char>
	utf8_reader (std::basic_string_view< Char >, std::string_view) -> utf8_reader< std::basic_string_view< Char > >
template<typename Char>
	utf8_reader (std::basic_string_view< Char >, std::string &&) -> utf8_reader< std::basic_string_view< Char > >
template<typename Char>
	utf8_reader (std::basic_istream< Char > &, std::string_view) -> utf8_reader< std::basic_istream< Char > >
template<typename Char>
	utf8_reader (std::basic_istream< Char > &, std::string &&) -> utf8_reader< std::basic_istream< Char > >
TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view	to_sv (node_type val) noexcept
TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view	to_sv (const std::string &str) noexcept
TOML_CONST_GETTER TOML_INTERNAL_LINKAGE std::string_view	to_sv (bool val) noexcept
TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view	to_sv (const utf8_codepoint &cp) noexcept
TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view	to_sv (const utf8_codepoint *cp) noexcept
template<typename T>
TOML_INTERNAL_LINKAGE void	concatenate (char &write_pos, char const buf_end, const T &arg) noexcept
	TOML_MAKE_FLAGS (formatted_string_traits)

Variables
	TOML_DISABLE_WARNINGS
	TOML_ENABLE_WARNINGS
	TOML_PUSH_WARNINGS
	TOML_DISABLE_SPAM_WARNINGS
	TOML_DISABLE_SWITCH_WARNINGS
	TOML_DISABLE_SUGGEST_ATTR_WARNINGS
	TOML_NAMESPACE_START
	TOML_NAMESPACE_END
	TOML_ABI_NAMESPACE_END
	TOML_IMPL_NAMESPACE_START
constexpr std::string_view	control_char_escapes []
constexpr std::string_view	node_type_friendly_names []
	TOML_IMPL_NAMESPACE_END
enum TOML_OPEN_FLAGS_ENUM	value_flags
enum TOML_OPEN_FLAGS_ENUM	format_as_binary = 1
enum TOML_OPEN_FLAGS_ENUM	format_as_octal = 2
enum TOML_OPEN_FLAGS_ENUM	format_as_hexadecimal = 3
constexpr value_flags	preserve_source_value_flags
enum TOML_CLOSED_FLAGS_ENUM	format_flags
enum TOML_CLOSED_FLAGS_ENUM	quote_dates_and_times = (1ull << 0)
enum TOML_CLOSED_FLAGS_ENUM	quote_infinities_and_nans = (1ull << 1)
enum TOML_CLOSED_FLAGS_ENUM	allow_literal_strings = (1ull << 2)
enum TOML_CLOSED_FLAGS_ENUM	allow_multi_line_strings = (1ull << 3)
enum TOML_CLOSED_FLAGS_ENUM	allow_real_tabs_in_strings = (1ull << 4)
enum TOML_CLOSED_FLAGS_ENUM	allow_unicode_strings = (1ull << 5)
enum TOML_CLOSED_FLAGS_ENUM	allow_binary_integers = (1ull << 6)
enum TOML_CLOSED_FLAGS_ENUM	allow_octal_integers = (1ull << 7)
enum TOML_CLOSED_FLAGS_ENUM	allow_hexadecimal_integers = (1ull << 8)
enum TOML_CLOSED_FLAGS_ENUM	indent_sub_tables = (1ull << 9)
enum TOML_CLOSED_FLAGS_ENUM	indent_array_elements = (1ull << 10)
enum TOML_CLOSED_FLAGS_ENUM	indentation = indent_sub_tables \| indent_array_elements
enum TOML_CLOSED_FLAGS_ENUM	relaxed_float_precision = (1ull << 11)
enum TOML_CLOSED_FLAGS_ENUM	terse_key_value_pairs = (1ull << 12)
template<typename T, typename... U>
constexpr bool	is_one_of = (false \|\| ... \|\| std::is_same_v<T, U>)
template<typename... T>
constexpr bool	all_integral = (std::is_integral_v<T> && ...)
template<typename T>
constexpr bool	is_cvref
template<typename T>
constexpr bool	is_wide_string
template<typename T>
constexpr bool	value_retrieval_is_nothrow
template<typename...>
constexpr bool	always_false = false
template<typename T, typename... U>
constexpr bool	first_is_same = false
template<typename T, typename... U>
constexpr bool	first_is_same< T, T, U... > = true
template<typename T>
constexpr bool	is_native = value_traits<T>::is_native
template<typename T>
constexpr bool	can_represent_native
template<typename T>
constexpr bool	can_partially_represent_native
template<typename T>
constexpr bool	is_losslessly_convertible_to_native
template<typename T, typename... U>
constexpr bool	is_natively_one_of = is_one_of<native_type_of<T>, U...>
template<typename T>
constexpr node_type	node_type_of
template<typename T, typename ConvertFrom>
constexpr bool	is_constructible_or_convertible
template<typename T>
constexpr bool	is_array = std::is_same_v<impl::remove_cvref<T>, array>
template<typename T>
constexpr bool	is_container = is_table<T> \|\| is_array<T>
template<typename T>
constexpr bool	is_string
template<typename T>
constexpr bool	is_integer
template<typename T>
constexpr bool	is_floating_point
template<typename T>
constexpr bool	is_number = is_integer<T> \|\| is_floating_point<T>
template<typename T>
constexpr bool	is_boolean
template<typename T>
constexpr bool	is_date
template<typename T>
constexpr bool	is_time
template<typename T>
constexpr bool	is_date_time
template<typename T>
constexpr bool	is_chronological
template<typename T>
constexpr bool	is_value
template<typename T>
constexpr bool	is_node
template<typename T>
constexpr bool	is_node_view
	TOML_POP_WARNINGS
	TOML_DISABLE_ARITHMETIC_WARNINGS
template<typename T>
constexpr bool	is_key
template<typename T>
constexpr bool	is_key_or_convertible
	literals::TOML_ABI_NAMESPACE_END
	TOML_ANON_NAMESPACE_START
template<>
constexpr size_t	charconv_buffer_length< int8_t > = 4
template<>
constexpr size_t	charconv_buffer_length< int16_t >
template<>
constexpr size_t	charconv_buffer_length< int32_t >
template<>
constexpr size_t	charconv_buffer_length< int64_t >
template<>
constexpr size_t	charconv_buffer_length< uint8_t > = 3
template<>
constexpr size_t	charconv_buffer_length< uint16_t >
template<>
constexpr size_t	charconv_buffer_length< uint32_t >
template<>
constexpr size_t	charconv_buffer_length< uint64_t >
template<>
constexpr size_t	charconv_buffer_length< float > = 64
template<>
constexpr size_t	charconv_buffer_length< double > = 64
	TOML_ANON_NAMESPACE_END
TOML_INTERNAL_LINKAGE constexpr auto	utf8_byte_order_mark = "\xEF\xBB\xBF"sv

Macro Definition Documentation

◆ advance_and_return_if_error

#define advance_and_return_if_error ( ... )

Value:

        do                                                                     \
        {                                                                      \
          assert_not_eof();                                                    \
          advance();                                                           \
          return_if_error(__VA_ARGS__);                                        \
        } while (false)

◆ advance_and_return_if_error_or_eof

#define advance_and_return_if_error_or_eof ( ... )

Value:

        do                                                                     \
        {                                                                      \
          assert_not_eof();                                                    \
          advance();                                                           \
          return_if_error(__VA_ARGS__);                                        \
          set_error_and_return_if_eof(__VA_ARGS__);                            \
        } while (false)

◆ assert_not_eof

#define assert_not_eof ( )

Value:

TOML_ASSERT_ASSUME(cp != nullptr)

TOML_ASSERT_ASSUME

#define TOML_ASSERT_ASSUME(expr)

Definition toml.hpp:1148

◆ assert_not_error

#define assert_not_error ( )

Value:

TOML_ASSERT(!is_error())

is_error

#define is_error()

Definition toml.hpp:14252

TOML_ASSERT

#define TOML_ASSERT(expr)

Definition toml.hpp:1143

◆ INCLUDE_TOMLPLUSPLUS_H

#define INCLUDE_TOMLPLUSPLUS_H

◆ is_eof

#define is_eof ( )

Value:

!cp

◆ is_error

#define is_error ( )

Value:

!!err

◆ parse_error_break

#define parse_error_break ( )

Value:

static_assert(true)

◆ POXY_IMPLEMENTATION_DETAIL

#define POXY_IMPLEMENTATION_DETAIL ( ... )

Value:

__VA_ARGS__

◆ push_parse_scope

#define push_parse_scope ( scope )

Value:

push_parse_scope_1(scope, __LINE__)

push_parse_scope_1

#define push_parse_scope_1(scope, line)

Definition toml.hpp:14127

◆ push_parse_scope_1

#define push_parse_scope_1	(		scope,
			line )

Value:

push_parse_scope_2(scope, line)

push_parse_scope_2

#define push_parse_scope_2(scope, line)

Definition toml.hpp:14125

◆ push_parse_scope_2

#define push_parse_scope_2	(		scope,
			line )

Value:

parse_scope ps_##line(current_scope, scope)

parse_scope

Definition toml.hpp:14105

◆ return_after_error

#define return_after_error ( ... )

Value:

return __VA_ARGS__

◆ return_if_eof

#define return_if_eof ( ... )

Value:

        do                                                                     \
        {                                                                      \
          if TOML_UNLIKELY (is_eof())                                          \
            return __VA_ARGS__;                                                \
        } while (false)

◆ return_if_error

#define return_if_error ( ... )

Value:

          do                                                                   \
          {                                                                    \
            if TOML_UNLIKELY (is_error())                                      \
              return __VA_ARGS__;                                              \
          } while (false)

◆ return_if_error_or_eof

#define return_if_error_or_eof ( ... )

Value:

          do                                                                   \
          {                                                                    \
            if TOML_UNLIKELY (is_eof() || is_error())                          \
              return __VA_ARGS__;                                              \
          } while (false)

◆ set_error_and_return

#define set_error_and_return	(		ret,
			... )

Value:

        do                                                                     \
        {                                                                      \
          if (!is_error())                                                     \
            set_error(__VA_ARGS__);                                            \
          return_after_error(ret);                                             \
        } while (false)

◆ set_error_and_return_default

#define set_error_and_return_default ( ... )

Value:

set_error_and_return({}, __VA_ARGS__)

set_error_and_return

#define set_error_and_return(ret,...)

Definition toml.hpp:14288

◆ set_error_and_return_if_eof

#define set_error_and_return_if_eof ( ... )

Value:

        do                                                                     \
        {                                                                      \
          if TOML_UNLIKELY (is_eof())                                          \
            set_error_and_return(__VA_ARGS__, "encountered end-of-file"sv);    \
        } while (false)

◆ TOML_ABI_NAMESPACE_BOOL

#define TOML_ABI_NAMESPACE_BOOL	(	cond,
		T,
		F )

Value:

TOML_ABI_NAMESPACE_START(TOML_CONCAT(TOML_EVAL_BOOL_, cond)(T, F))

cond

pthread_cond_t cond

Definition cuda.h:50

T

#define T

Definition exp2f.c:24

TOML_CONCAT

#define TOML_CONCAT(x, y)

Definition toml.hpp:388

TOML_ABI_NAMESPACE_START

#define TOML_ABI_NAMESPACE_START(name)

Definition toml.hpp:1247

◆ TOML_ABI_NAMESPACE_END

#define TOML_ABI_NAMESPACE_END } static_assert(true)

◆ TOML_ABI_NAMESPACE_START

#define TOML_ABI_NAMESPACE_START ( name )

Value:

inline namespace name { static_assert(true)

◆ TOML_ABI_NAMESPACES

#define TOML_ABI_NAMESPACES 1

◆ TOML_ABSTRACT_INTERFACE

#define TOML_ABSTRACT_INTERFACE TOML_DECLSPEC(novtable)

◆ TOML_ALWAYS_INLINE

#define TOML_ALWAYS_INLINE inline

◆ TOML_ANON_NAMESPACE

#define TOML_ANON_NAMESPACE TOML_NAMESPACE::impl

◆ TOML_ANON_NAMESPACE_END

#define TOML_ANON_NAMESPACE_END TOML_IMPL_NAMESPACE_END

◆ TOML_ANON_NAMESPACE_START

#define TOML_ANON_NAMESPACE_START static_assert(TOML_IMPLEMENTATION); TOML_IMPL_NAMESPACE_START

◆ TOML_ARCH_AMD64

#define TOML_ARCH_AMD64 0

◆ TOML_ARCH_ARM

#define TOML_ARCH_ARM 0

◆ TOML_ARCH_ARM32

#define TOML_ARCH_ARM32 0

◆ TOML_ARCH_ARM64

#define TOML_ARCH_ARM64 0

◆ TOML_ARCH_BITNESS

#define TOML_ARCH_BITNESS 0

◆ TOML_ARCH_ITANIUM

#define TOML_ARCH_ITANIUM 0

◆ TOML_ARCH_X64

#define TOML_ARCH_X64 0

◆ TOML_ARCH_X86

#define TOML_ARCH_X86 0

◆ TOML_ASSERT

#define TOML_ASSERT ( expr )

Value:

assert(expr)

◆ TOML_ASSERT_ASSUME

#define TOML_ASSERT_ASSUME ( expr )

Value:

TOML_ASSERT(expr)

◆ TOML_ASSUME

#define TOML_ASSUME ( expr )

Value:

static_cast<void>(0)

◆ TOML_ASYMMETRICAL_EQUALITY_OPS

#define TOML_ASYMMETRICAL_EQUALITY_OPS	(	LHS,
		RHS,
		... )

Value:

  __VA_ARGS__ TOML_NODISCARD friend bool operator==(RHS rhs, LHS lhs) noexcept \
  {                                                                            \
    return lhs == rhs;                                                         \
  }                                                                            \
  __VA_ARGS__ TOML_NODISCARD friend bool operator!=(LHS lhs, RHS rhs) noexcept \
  {                                                                            \
    return !(lhs == rhs);                                                      \
  }                                                                            \
  __VA_ARGS__ TOML_NODISCARD friend bool operator!=(RHS rhs, LHS lhs) noexcept \
  {                                                                            \
    return !(lhs == rhs);                                                      \
  }                                                                            \
  static_assert(true)

◆ TOML_ATTR

#define TOML_ATTR ( ... )

◆ TOML_CALLCONV

#define TOML_CALLCONV

◆ TOML_CLANG

#define TOML_CLANG 0

◆ TOML_CLOSED_ENUM

#define TOML_CLOSED_ENUM

◆ TOML_CLOSED_FLAGS_ENUM

#define TOML_CLOSED_FLAGS_ENUM TOML_CLOSED_ENUM TOML_FLAGS_ENUM

◆ TOML_COMPILER_HAS_EXCEPTIONS

#define TOML_COMPILER_HAS_EXCEPTIONS 0

◆ TOML_COMPILER_HAS_RTTI

#define TOML_COMPILER_HAS_RTTI 0

◆ TOML_CONCAT

#define TOML_CONCAT	(		x,
			y )

Value:

TOML_CONCAT_1(x, y)

TOML_CONCAT_1

#define TOML_CONCAT_1(x, y)

Definition toml.hpp:387

◆ TOML_CONCAT_1

#define TOML_CONCAT_1	(		x,
			y )

Value:

x##y

◆ TOML_CONST

#define TOML_CONST

◆ TOML_CONST_GETTER

#define TOML_CONST_GETTER

Value:

TOML_NODISCARD \

TOML_CONST

◆ TOML_CONST_INLINE_GETTER

#define TOML_CONST_INLINE_GETTER

Value:

    TOML_NODISCARD                                                             \
    TOML_ALWAYS_INLINE                                                         \
    TOML_CONST

◆ TOML_CONSTRAINED_TEMPLATE

#define TOML_CONSTRAINED_TEMPLATE	(		condition,
			... )

Value:

template <__VA_ARGS__ TOML_ENABLE_IF(condition)> \

TOML_REQUIRES(condition)

◆ TOML_CPP [1/2]

#define TOML_CPP 0

◆ TOML_CPP [2/2]

#define TOML_CPP __cplusplus

◆ TOML_CUDA

#define TOML_CUDA 0

◆ TOML_DECLSPEC

#define TOML_DECLSPEC ( ... )

◆ TOML_DELETE_DEFAULTS

#define TOML_DELETE_DEFAULTS ( T )

Value:

  T(const T &) = delete;                                                       \
  T(T &&) = delete;                                                            \
  T &operator=(const T &) = delete;                                            \
  T &operator=(T &&) = delete

◆ TOML_DISABLE_ARITHMETIC_WARNINGS

#define TOML_DISABLE_ARITHMETIC_WARNINGS static_assert(true)

◆ TOML_DISABLE_CODE_ANALYSIS_WARNINGS

#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS static_assert(true)

◆ TOML_DISABLE_SPAM_WARNINGS

#define TOML_DISABLE_SPAM_WARNINGS static_assert(true)

◆ TOML_DISABLE_SUGGEST_ATTR_WARNINGS

#define TOML_DISABLE_SUGGEST_ATTR_WARNINGS static_assert(true)

◆ TOML_DISABLE_SWITCH_WARNINGS

#define TOML_DISABLE_SWITCH_WARNINGS static_assert(true)

◆ TOML_DISABLE_WARNINGS

#define TOML_DISABLE_WARNINGS static_assert(true)

◆ TOML_DOXYGEN

#define TOML_DOXYGEN 0

◆ TOML_EMPTY_BASES

#define TOML_EMPTY_BASES TOML_DECLSPEC(empty_bases)

◆ TOML_ENABLE_FLOAT16

#define TOML_ENABLE_FLOAT16 0

◆ TOML_ENABLE_FORMATTERS

#define TOML_ENABLE_FORMATTERS 1

◆ TOML_ENABLE_IF

#define TOML_ENABLE_IF ( ... )

Value:

, typename std::enable_if<(__VA_ARGS__), int>::type = 0

◆ TOML_ENABLE_PARSER

#define TOML_ENABLE_PARSER 1

◆ TOML_ENABLE_SIMD

#define TOML_ENABLE_SIMD 1

◆ TOML_ENABLE_UNRELEASED_FEATURES

#define TOML_ENABLE_UNRELEASED_FEATURES 0

◆ TOML_ENABLE_WARNINGS

#define TOML_ENABLE_WARNINGS static_assert(true)

◆ TOML_ENABLE_WINDOWS_COMPAT [1/2]

#define TOML_ENABLE_WINDOWS_COMPAT 0

◆ TOML_ENABLE_WINDOWS_COMPAT [2/2]

#define TOML_ENABLE_WINDOWS_COMPAT 1

◆ TOML_ENV_MESSAGE

#define TOML_ENV_MESSAGE

Value:

    "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!"

◆ TOML_EVAL_BOOL_0

#define TOML_EVAL_BOOL_0	(		T,
			F )

Value:

F

◆ TOML_EVAL_BOOL_1

#define TOML_EVAL_BOOL_1	(		T,
			F )

Value:

T

◆ TOML_EXCEPTIONS

#define TOML_EXCEPTIONS 0

◆ TOML_EXPORTED_CLASS

#define TOML_EXPORTED_CLASS

◆ TOML_EXPORTED_FREE_FUNCTION

#define TOML_EXPORTED_FREE_FUNCTION

◆ TOML_EXPORTED_MEMBER_FUNCTION

#define TOML_EXPORTED_MEMBER_FUNCTION

◆ TOML_EXPORTED_STATIC_FUNCTION

#define TOML_EXPORTED_STATIC_FUNCTION

◆ TOML_EXTERNAL_LINKAGE

#define TOML_EXTERNAL_LINKAGE inline

◆ TOML_FLAGS_ENUM

#define TOML_FLAGS_ENUM

◆ TOML_FLOAT_CHARCONV [1/2]

#define TOML_FLOAT_CHARCONV 0

◆ TOML_FLOAT_CHARCONV [2/2]

#define TOML_FLOAT_CHARCONV 1

◆ TOML_GCC

#define TOML_GCC 0

◆ TOML_GCC_LIKE

#define TOML_GCC_LIKE 0

◆ TOML_HAS_ATTR

#define TOML_HAS_ATTR ( attr )

Value:

0

◆ TOML_HAS_BUILTIN

#define TOML_HAS_BUILTIN ( name )

Value:

0

◆ TOML_HAS_CHAR8

#define TOML_HAS_CHAR8 0

◆ TOML_HAS_CPP_ATTR

#define TOML_HAS_CPP_ATTR ( attr )

Value:

0

◆ TOML_HAS_CUSTOM_OPTIONAL_TYPE

#define TOML_HAS_CUSTOM_OPTIONAL_TYPE 0

◆ TOML_HAS_FEATURE

#define TOML_HAS_FEATURE ( name )

Value:

0

◆ TOML_HAS_INCLUDE

#define TOML_HAS_INCLUDE ( header )

Value:

0

◆ TOML_HAS_SSE2

#define TOML_HAS_SSE2 0

◆ TOML_HAS_SSE4_1

#define TOML_HAS_SSE4_1 0

◆ TOML_HEADER_ONLY

#define TOML_HEADER_ONLY 1

◆ TOML_HIDDEN_CONSTRAINT

#define TOML_HIDDEN_CONSTRAINT	(		condition,
			... )

Value:

TOML_CONSTRAINED_TEMPLATE(condition, __VA_ARGS__)

TOML_CONSTRAINED_TEMPLATE

#define TOML_CONSTRAINED_TEMPLATE(condition,...)

Definition toml.hpp:1187

◆ TOML_ICC

#define TOML_ICC 0

◆ TOML_ICC_CL

#define TOML_ICC_CL 0

◆ TOML_IMPL_NAMESPACE_END

#define TOML_IMPL_NAMESPACE_END } TOML_NAMESPACE_END

◆ TOML_IMPL_NAMESPACE_START

#define TOML_IMPL_NAMESPACE_START TOML_NAMESPACE_START { namespace impl

◆ TOML_IMPLEMENTATION

#define TOML_IMPLEMENTATION 1

◆ TOML_INCLUDE_WINDOWS_H

#define TOML_INCLUDE_WINDOWS_H 0

◆ TOML_INLINE_GETTER

#define TOML_INLINE_GETTER

Value:

TOML_NODISCARD \

TOML_ALWAYS_INLINE

◆ TOML_INT_CHARCONV [1/2]

#define TOML_INT_CHARCONV 0

◆ TOML_INT_CHARCONV [2/2]

#define TOML_INT_CHARCONV 1

◆ TOML_INTELLISENSE

#define TOML_INTELLISENSE 0

◆ TOML_INTERNAL_LINKAGE

#define TOML_INTERNAL_LINKAGE inline

◆ TOML_LANG_AT_LEAST

#define TOML_LANG_AT_LEAST	(	major,
		minor,
		patch )

Value:

(TOML_LANG_EFFECTIVE_VERSION >= TOML_MAKE_VERSION(major, minor, patch))

TOML_MAKE_VERSION

#define TOML_MAKE_VERSION(major, minor, patch)

Definition toml.hpp:99

TOML_LANG_EFFECTIVE_VERSION

#define TOML_LANG_EFFECTIVE_VERSION

Definition toml.hpp:1223

◆ TOML_LANG_EFFECTIVE_VERSION

#define TOML_LANG_EFFECTIVE_VERSION TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)

◆ TOML_LANG_HIGHER_THAN

#define TOML_LANG_HIGHER_THAN	(	major,
		minor,
		patch )

Value:

(TOML_LANG_EFFECTIVE_VERSION > TOML_MAKE_VERSION(major, minor, patch))

◆ TOML_LANG_MAJOR

#define TOML_LANG_MAJOR 1

◆ TOML_LANG_MINOR

#define TOML_LANG_MINOR 0

◆ TOML_LANG_PATCH

#define TOML_LANG_PATCH 0

◆ TOML_LANG_UNRELEASED

#define TOML_LANG_UNRELEASED TOML_LANG_HIGHER_THAN(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)

◆ TOML_LAUNDER

#define TOML_LAUNDER ( x )

Value:

x

◆ TOML_LIB_MAJOR

#define TOML_LIB_MAJOR 3

◆ TOML_LIB_MINOR

#define TOML_LIB_MINOR 4

◆ TOML_LIB_PATCH

#define TOML_LIB_PATCH 0

◆ TOML_LIB_SINGLE_HEADER

#define TOML_LIB_SINGLE_HEADER 1

◆ TOML_LIFETIME_HOOKS

#define TOML_LIFETIME_HOOKS 0

◆ TOML_LIKELY

#define TOML_LIKELY ( ... )

Value:

(__VA_ARGS__)

◆ TOML_LIKELY_CASE

#define TOML_LIKELY_CASE

◆ TOML_LINUX

#define TOML_LINUX 0

◆ TOML_MAKE_FLAGS

#define TOML_MAKE_FLAGS ( T )

Value:

TOML_MAKE_FLAGS_1(T, )

TOML_MAKE_FLAGS_1

#define TOML_MAKE_FLAGS_1(T, linkage)

Definition toml.hpp:637

◆ TOML_MAKE_FLAGS_1

#define TOML_MAKE_FLAGS_1	(		T,
			linkage )

Value:

  static_assert(std::is_enum_v<T>);                                            \
                                                                               \
  TOML_MAKE_FLAGS_2(T, &, linkage);                                            \
  TOML_MAKE_FLAGS_2(T, |, linkage);                                            \
  TOML_MAKE_FLAGS_2(T, ^, linkage);                                            \
                                                                               \
  TOML_CONST_INLINE_GETTER                                                     \
  linkage constexpr T operator~(T val) noexcept                                \
  {                                                                            \
    using under = std::underlying_type_t<T>;                                   \
    return static_cast<T>(~static_cast<under>(val));                           \
  }                                                                            \
                                                                               \
  TOML_CONST_INLINE_GETTER                                                     \
  linkage constexpr bool operator!(T val) noexcept                             \
  {                                                                            \
    using under = std::underlying_type_t<T>;                                   \
    return !static_cast<under>(val);                                           \
  }                                                                            \
                                                                               \
  static_assert(true)

◆ TOML_MAKE_FLAGS_2

#define TOML_MAKE_FLAGS_2	(	T,
		op,
		linkage )

Value:

  TOML_CONST_INLINE_GETTER                                                     \
  linkage constexpr T operator op(T lhs, T rhs) noexcept                       \
  {                                                                            \
    using under = std::underlying_type_t<T>;                                   \
    return static_cast<T>(static_cast<under>(lhs) op static_cast<under>(rhs)); \
  }                                                                            \
                                                                               \
  linkage constexpr T &operator TOML_CONCAT(op, =)(T &lhs, T rhs) noexcept     \
  {                                                                            \
    return lhs = (lhs op rhs);                                                 \
  }                                                                            \
                                                                               \
  static_assert(true)

◆ TOML_MAKE_STRING

#define TOML_MAKE_STRING ( s )

Value:

TOML_MAKE_STRING_1(s)

TOML_MAKE_STRING_1

#define TOML_MAKE_STRING_1(s)

Definition toml.hpp:391

◆ TOML_MAKE_STRING_1

#define TOML_MAKE_STRING_1 ( s )

Value:

#s

◆ TOML_MAKE_VERSION

#define TOML_MAKE_VERSION	(	major,
		minor,
		patch )

Value:

(((major)*10000) + ((minor)*100) + ((patch)))

◆ TOML_MAX_NESTED_VALUES

#define TOML_MAX_NESTED_VALUES 256

◆ TOML_MSVC

#define TOML_MSVC 0

◆ TOML_MSVC_LIKE

#define TOML_MSVC_LIKE 0

◆ TOML_NAMESPACE

#define TOML_NAMESPACE ::toml::TOML_CONCAT(v, TOML_LIB_MAJOR)

◆ TOML_NAMESPACE_END

#define TOML_NAMESPACE_END } static_assert(true)

◆ TOML_NAMESPACE_START

#define TOML_NAMESPACE_START namespace toml { inline namespace TOML_CONCAT(v, TOML_LIB_MAJOR)

◆ TOML_NEVER_INLINE

#define TOML_NEVER_INLINE

◆ TOML_NODISCARD

#define TOML_NODISCARD

◆ TOML_NODISCARD_CTOR

#define TOML_NODISCARD_CTOR

◆ TOML_NVCC

#define TOML_NVCC 0

◆ TOML_NVCC_WORKAROUND

#define TOML_NVCC_WORKAROUND = 0

◆ TOML_OPEN_ENUM

#define TOML_OPEN_ENUM

◆ TOML_OPEN_FLAGS_ENUM

#define TOML_OPEN_FLAGS_ENUM TOML_OPEN_ENUM TOML_FLAGS_ENUM

◆ TOML_OVERALIGNED

#define TOML_OVERALIGNED alignas(32)

◆ TOML_PARSE_ERROR_BASE

#define TOML_PARSE_ERROR_BASE

◆ TOML_PARSE_FILE_ERROR

#define TOML_PARSE_FILE_ERROR	(		msg,
			path )

Value:

        return parse_result(parse_error(                                       \
          msg,                                                                 \
          source_position{},                                                   \
          std::make_shared<const std::string>(std::move(path))))

◆ TOML_PARSER_TYPENAME

#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_noex::parser

◆ TOML_POP_WARNINGS

#define TOML_POP_WARNINGS static_assert(true)

◆ TOML_PRAGMA_CLANG

#define TOML_PRAGMA_CLANG ( decl )

◆ TOML_PRAGMA_CLANG_GE_10

#define TOML_PRAGMA_CLANG_GE_10 ( decl )

◆ TOML_PRAGMA_CLANG_GE_11

#define TOML_PRAGMA_CLANG_GE_11 ( decl )

◆ TOML_PRAGMA_CLANG_GE_8

#define TOML_PRAGMA_CLANG_GE_8 ( decl )

◆ TOML_PRAGMA_CLANG_GE_9

#define TOML_PRAGMA_CLANG_GE_9 ( decl )

◆ TOML_PRAGMA_GCC

#define TOML_PRAGMA_GCC ( decl )

◆ TOML_PRAGMA_ICC

#define TOML_PRAGMA_ICC ( ... )

◆ TOML_PRAGMA_MSVC

#define TOML_PRAGMA_MSVC ( ... )

◆ TOML_PURE

#define TOML_PURE

◆ TOML_PURE_GETTER

#define TOML_PURE_GETTER

Value:

TOML_NODISCARD \

TOML_PURE

◆ TOML_PURE_INLINE_GETTER

#define TOML_PURE_INLINE_GETTER

Value:

    TOML_NODISCARD                                                             \
    TOML_ALWAYS_INLINE                                                         \
    TOML_PURE

◆ TOML_PUSH_WARNINGS

#define TOML_PUSH_WARNINGS static_assert(true)

◆ TOML_REQUIRES

#define TOML_REQUIRES ( ... )

◆ TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN

#define TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN 0

◆ TOML_RETURNS_BY_THROWING

#define TOML_RETURNS_BY_THROWING

◆ TOML_SA_LIST_BEG

#define TOML_SA_LIST_BEG TOML_SA_LIST_SEP

◆ TOML_SA_LIST_END

#define TOML_SA_LIST_END

◆ TOML_SA_LIST_NEW

#define TOML_SA_LIST_NEW TOML_SA_NEWLINE TOML_SA_NEWLINE

◆ TOML_SA_LIST_NXT

#define TOML_SA_LIST_NXT TOML_SA_LIST_NEW

◆ TOML_SA_LIST_SEP

#define TOML_SA_LIST_SEP TOML_SA_NEWLINE " - "

◆ TOML_SA_NATIVE_VALUE_TYPE_LIST

#define TOML_SA_NATIVE_VALUE_TYPE_LIST

Value:

    TOML_SA_LIST_BEG    "std::string"                           \
    TOML_SA_LIST_SEP    "int64_t"                               \
    TOML_SA_LIST_SEP    "double"                                \
    TOML_SA_LIST_SEP    "bool"                                  \
    TOML_SA_LIST_SEP    "toml::date"                            \
    TOML_SA_LIST_SEP    "toml::time"                            \
    TOML_SA_LIST_SEP    "toml::date_time"                       \
    TOML_SA_LIST_END

◆ TOML_SA_NEWLINE

#define TOML_SA_NEWLINE "\n| "

◆ TOML_SA_NODE_TYPE_LIST

#define TOML_SA_NODE_TYPE_LIST

Value:

    TOML_SA_LIST_BEG    "toml::table"                           \
    TOML_SA_LIST_SEP    "toml::array"                           \
    TOML_SA_LIST_SEP    "toml::value<std::string>"              \
    TOML_SA_LIST_SEP    "toml::value<int64_t>"                  \
    TOML_SA_LIST_SEP    "toml::value<double>"                   \
    TOML_SA_LIST_SEP    "toml::value<bool>"                     \
    TOML_SA_LIST_SEP    "toml::value<toml::date>"               \
    TOML_SA_LIST_SEP    "toml::value<toml::time>"               \
    TOML_SA_LIST_SEP    "toml::value<toml::date_time>"          \
    TOML_SA_LIST_END

◆ TOML_SA_UNWRAPPED_NODE_TYPE_LIST

#define TOML_SA_UNWRAPPED_NODE_TYPE_LIST

Value:

    TOML_SA_LIST_NEW    "A native TOML value type"              \
    TOML_SA_NATIVE_VALUE_TYPE_LIST                              \
                                                                \
    TOML_SA_LIST_NXT    "A TOML node type"                      \
    TOML_SA_NODE_TYPE_LIST

◆ TOML_SA_VALUE_EXACT_FUNC_MESSAGE

#define TOML_SA_VALUE_EXACT_FUNC_MESSAGE ( type_arg )

Value:

    "The " type_arg " must be one of:"                                                                      \
    TOML_SA_LIST_NEW "A native TOML value type"                                                             \
    TOML_SA_NATIVE_VALUE_TYPE_LIST                                                                          \
                                                                                                            \
    TOML_SA_LIST_NXT "A non-view type capable of losslessly representing a native TOML value type"          \
    TOML_SA_LIST_BEG "std::string"                                                                          \
    TOML_SA_VALUE_MESSAGE_WSTRING                                                                           \
    TOML_SA_LIST_SEP "any signed integer type >= 64 bits"                                                   \
    TOML_SA_LIST_SEP "any floating-point type >= 64 bits"                                                   \
    TOML_SA_LIST_END                                                                                        \
                                                                                                            \
    TOML_SA_LIST_NXT "An immutable view type not requiring additional temporary storage"                    \
    TOML_SA_LIST_BEG "std::string_view"                                                                     \
    TOML_SA_VALUE_MESSAGE_U8STRING_VIEW                                                                     \
    TOML_SA_LIST_SEP "const char*"                                                                          \
    TOML_SA_VALUE_MESSAGE_CONST_CHAR8                                                                       \
        TOML_SA_LIST_END

◆ TOML_SA_VALUE_FUNC_MESSAGE

#define TOML_SA_VALUE_FUNC_MESSAGE ( type_arg )

Value:

    "The " type_arg " must be one of:"                                                                      \
    TOML_SA_LIST_NEW "A native TOML value type"                                                             \
    TOML_SA_NATIVE_VALUE_TYPE_LIST                                                                          \
                                                                                                            \
    TOML_SA_LIST_NXT "A non-view type capable of losslessly representing a native TOML value type"          \
    TOML_SA_LIST_BEG "std::string"                                                                          \
    TOML_SA_VALUE_MESSAGE_WSTRING                                                                           \
    TOML_SA_LIST_SEP "any signed integer type >= 64 bits"                                                   \
    TOML_SA_LIST_SEP "any floating-point type >= 64 bits"                                                   \
    TOML_SA_LIST_END                                                                                        \
                                                                                                            \
    TOML_SA_LIST_NXT "A non-view type capable of (reasonably) representing a native TOML value type"        \
    TOML_SA_LIST_BEG "any other integral type"                                                              \
    TOML_SA_LIST_SEP "any floating-point type"                                                              \
    TOML_SA_LIST_END                                                                                        \
                                                                                                            \
    TOML_SA_LIST_NXT "An immutable view type not requiring additional temporary storage"                    \
    TOML_SA_LIST_BEG "std::string_view"                                                                     \
    TOML_SA_VALUE_MESSAGE_U8STRING_VIEW                                                                     \
    TOML_SA_LIST_SEP "const char*"                                                                          \
    TOML_SA_VALUE_MESSAGE_CONST_CHAR8                                                                       \
    TOML_SA_LIST_END

◆ TOML_SA_VALUE_MESSAGE_CONST_CHAR8

#define TOML_SA_VALUE_MESSAGE_CONST_CHAR8

◆ TOML_SA_VALUE_MESSAGE_U8STRING_VIEW

#define TOML_SA_VALUE_MESSAGE_U8STRING_VIEW

◆ TOML_SA_VALUE_MESSAGE_WSTRING

#define TOML_SA_VALUE_MESSAGE_WSTRING

◆ TOML_SHARED_LIB

#define TOML_SHARED_LIB 0

◆ TOML_SIMPLE_STATIC_ASSERT_MESSAGES

#define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 0

◆ TOML_TRIVIAL_ABI

#define TOML_TRIVIAL_ABI

◆ TOML_UNDEF_MACROS

#define TOML_UNDEF_MACROS 1

◆ TOML_UNIX

#define TOML_UNIX 0

◆ TOML_UNLIKELY

#define TOML_UNLIKELY ( ... )

Value:

(__VA_ARGS__)

◆ TOML_UNLIKELY_CASE

#define TOML_UNLIKELY_CASE

◆ TOML_UNREACHABLE

#define TOML_UNREACHABLE static_cast<void>(0)

◆ TOML_UNUSED

#define TOML_UNUSED ( ... )

Value:

static_cast<void>(__VA_ARGS__)

◆ TOML_WINDOWS

#define TOML_WINDOWS 0

◆ TOMLPLUSPLUS_H

#define TOMLPLUSPLUS_H

◆ utf8_buffered_reader_error_check

#define utf8_buffered_reader_error_check ( ... )

Value:

        do                                                                     \
        {                                                                      \
          if TOML_UNLIKELY (reader_.error())                                   \
            return __VA_ARGS__;                                                \
        } while (false)

◆ utf8_reader_error

#define utf8_reader_error ( ... )

Value:

err_.emplace(__VA_ARGS__)

◆ utf8_reader_error_check

#define utf8_reader_error_check ( ... )

Value:

        do                                                                     \
        {                                                                      \
          if TOML_UNLIKELY (err_)                                              \
            return __VA_ARGS__;                                                \
        } while (false)

◆ utf8_reader_return_after_error

#define utf8_reader_return_after_error ( ... )

Value:

return __VA_ARGS__

Typedef Documentation

◆ common_signed_type

template<typename... T>

using common_signed_type = std::common_type_t<std::make_signed_t<T>...>

◆ const_array_iterator

using const_array_iterator

Initial value:

POXY_IMPLEMENTATION_DETAIL(impl::array_iterator<true>)

POXY_IMPLEMENTATION_DETAIL

#define POXY_IMPLEMENTATION_DETAIL(...)

Definition toml.hpp:688

◆ const_table_iterator

using const_table_iterator

Initial value:

POXY_IMPLEMENTATION_DETAIL(impl::table_iterator<true>)

◆ copy_cv

template<typename Dest, typename Src>

using copy_cv = typename copy_cv_<Dest, Src>::type

◆ copy_cvref

template<typename Dest, typename Src>

using copy_cvref

Initial value:

 copy_ref<
    copy_ref<
      copy_cv<std::remove_reference_t<Dest>, std::remove_reference_t<Src>>,
      Dest>,
    Src>

◆ copy_ref

template<typename Dest, typename Src>

using copy_ref = typename copy_ref_<Dest, Src>::type

◆ default_formatter

using default_formatter = toml_formatter

◆ emplaced_type_of

template<typename... T>

using emplaced_type_of = typename emplaced_type_of_<remove_cvref<T>...>::type

◆ native_type_of

template<typename T>

using native_type_of = typename value_traits<T>::native_type

◆ source_path_ptr

using source_path_ptr = std::shared_ptr<const std::string>

◆ underlying_type

template<typename T>

using underlying_type = typename underlying_type_<T>::type

◆ unwrap_node

template<typename T>

using unwrap_node = typename node_unwrapper<std::remove_reference_t<T>>::type

◆ wrap_node

template<typename T>

using wrap_node = typename node_wrapper<std::remove_reference_t<T>>::type

Function Documentation

◆ at_path() [1/3]

TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION node_view< const node > TOML_CALLCONV at_path	(	const node &	root,
		const toml::path &	path )

noexcept

◆ at_path() [2/3]

TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION node_view< const node > TOML_CALLCONV at_path	(	const node &	root,
		std::string_view	path )

noexcept

◆ at_path() [3/3]

TOML_NODISCARD TOML_EXPORTED_FREE_FUNCTION node_view< node > TOML_CALLCONV at_path	(	node &	root,
		const toml::path &	path )

noexcept

◆ concatenate()

template<typename T>

TOML_INTERNAL_LINKAGE void concatenate	(	char *&	write_pos,
		char *const	buf_end,
		const T &	arg )

noexcept

◆ find()

template<typename Iterator, typename T>

TOML_PURE_GETTER auto find	(	Iterator	start,
		Iterator	end,
		const T &	needle )->decltype(&(*start))

inlinenoexcept

◆ fpclassify()

TOML_PURE_GETTER fp_class fpclassify ( const double & val )

inlinenoexcept

◆ inserter() [1/2]

template<typename T>

inserter ( T && ) ->inserter< T && >

◆ inserter() [2/2]

template<typename T>

inserter ( T & ) ->inserter< T & >

◆ is_ascii()

TOML_PURE_GETTER bool is_ascii	(	const char *	str,
		size_t	len )

noexcept

◆ make_node()

template<typename T>

TOML_NODISCARD node_ptr make_node	(	T &&	val,
		value_flags	flags = preserve_source_value_flags )

◆ min()

template<typename T>

TOML_PURE_INLINE_GETTER constexpr const T & min	(	const T &	a,
		const T &	b )

constexprnoexcept

◆ node_integer_cast()

template<typename T>

TOML_CONST_GETTER optional< T > node_integer_cast ( int64_t val )

inlinenoexcept

◆ node_view() [1/4]

template<typename T>

node_view ( const T & ) ->node_view< constnode >

◆ node_view() [2/4]

template<typename T>

node_view ( const T * ) ->node_view< constnode >

◆ node_view() [3/4]

template<typename T>

node_view ( T & ) ->node_view< node >

◆ node_view() [4/4]

template<typename T>

node_view ( T * ) ->node_view< node >

◆ operator<<()

template<typename Char>

std::basic_ostream< Char > & operator<<	(	std::basic_ostream< Char > &	lhs,
		node_type	rhs )

inline

◆ parse() [1/4]

TOML_EXTERNAL_LINKAGE parse_result TOML_CALLCONV parse	(	std::istream &	doc,
		std::string &&	source_path )

◆ parse() [2/4]

TOML_EXTERNAL_LINKAGE parse_result TOML_CALLCONV parse	(	std::istream &	doc,
		std::string_view	source_path = {} )

◆ parse() [3/4]

TOML_EXTERNAL_LINKAGE parse_result TOML_CALLCONV parse	(	std::string_view	doc,
		std::string &&	source_path )

◆ parse() [4/4]

TOML_EXTERNAL_LINKAGE parse_result TOML_CALLCONV parse	(	std::string_view	doc,
		std::string_view	source_path = {} )

◆ parse_file()

TOML_EXTERNAL_LINKAGE parse_result TOML_CALLCONV parse_file ( std::string_view file_path )

◆ parse_path()

TOML_NODISCARD bool TOML_CALLCONV parse_path	(	std::string_view	,
		void *	,
		parse_path_callback< std::string_view >	,
		parse_path_callback< size_t >	)

◆ print_floating_point_to_stream()

template<typename T>

TOML_INTERNAL_LINKAGE void print_floating_point_to_stream	(	std::ostream &	stream,
		T	val,
		value_flags	format,
		bool	relaxed_precision )

◆ print_integer_to_stream()

template<typename T>

TOML_INTERNAL_LINKAGE void print_integer_to_stream	(	std::ostream &	stream,
		T	val,
		value_flags	format = {},
		size_t	min_digits = 0 )

◆ print_to_stream() [1/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		bool	)

◆ print_to_stream() [2/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		char	)

◆ print_to_stream() [3/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const array &	)

◆ print_to_stream() [4/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const source_position &	)

◆ print_to_stream() [5/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const source_region &	)

◆ print_to_stream() [6/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const std::string &	)

◆ print_to_stream() [7/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const table &	)

◆ print_to_stream() [8/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const toml::date &	)

◆ print_to_stream() [9/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const toml::date_time &	)

◆ print_to_stream() [10/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const toml::time &	)

◆ print_to_stream() [11/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const toml::time_offset &	)

◆ print_to_stream() [12/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const value< bool > &	)

◆ print_to_stream() [13/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const value< date > &	)

◆ print_to_stream() [14/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const value< date_time > &	)

◆ print_to_stream() [15/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const value< double > &	)

◆ print_to_stream() [16/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const value< int64_t > &	)

◆ print_to_stream() [17/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const value< std::string > &	)

◆ print_to_stream() [18/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		const value< time > &	)

◆ print_to_stream() [19/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		double	,
		value_flags	= {},
		bool	relaxed_precision = false )

◆ print_to_stream() [20/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		float	,
		value_flags	= {},
		bool	relaxed_precision = false )

◆ print_to_stream() [21/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		signed char	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [22/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		signed int	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [23/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		signed long long	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [24/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		signed long	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [25/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		signed short	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [26/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		std::string_view	)

◆ print_to_stream() [27/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		unsigned char	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [28/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		unsigned int	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [29/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		unsigned long long	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [30/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		unsigned long	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream() [31/31]

TOML_EXPORTED_FREE_FUNCTION void TOML_CALLCONV print_to_stream	(	std::ostream &	,
		unsigned short	,
		value_flags	= {},
		size_t	min_digits = 0 )

◆ print_to_stream_bookended()

template<typename T, typename U>

void print_to_stream_bookended	(	std::ostream &	stream,
		const T &	val,
		const U &	bookend )

inline

◆ to_sv() [1/5]

TOML_CONST_GETTER TOML_INTERNAL_LINKAGE std::string_view to_sv ( bool val )

noexcept

◆ to_sv() [2/5]

TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view to_sv ( const std::string & str )

noexcept

◆ to_sv() [3/5]

TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view to_sv ( const utf8_codepoint & cp )

noexcept

◆ to_sv() [4/5]

TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view to_sv ( const utf8_codepoint * cp )

noexcept

◆ to_sv() [5/5]

TOML_PURE_GETTER TOML_INTERNAL_LINKAGE std::string_view to_sv ( node_type val )

noexcept

◆ TOML_ABI_NAMESPACE_BOOL() [1/3]

TOML_ABI_NAMESPACE_BOOL	(	TOML_EXCEPTIONS	,
		ex	,
		noex	)

◆ TOML_ABI_NAMESPACE_BOOL() [2/3]

TOML_ABI_NAMESPACE_BOOL	(	TOML_EXCEPTIONS	,
		impl_ex	,
		impl_noex	)

◆ TOML_ABI_NAMESPACE_BOOL() [3/3]

TOML_ABI_NAMESPACE_BOOL	(	TOML_HAS_CUSTOM_OPTIONAL_TYPE	,
		custopt	,
		stdopt	)

◆ TOML_MAKE_FLAGS() [1/3]

enum TOML_CLOSED_FLAGS_ENUM TOML_MAKE_FLAGS ( format_flags )

◆ TOML_MAKE_FLAGS() [2/3]

TOML_MAKE_FLAGS ( formatted_string_traits )

◆ TOML_MAKE_FLAGS() [3/3]

enum TOML_OPEN_FLAGS_ENUM TOML_MAKE_FLAGS ( value_flags )

◆ utf8_reader() [1/4]

template<typename Char>

utf8_reader	(	std::basic_istream< Char > &	,
		std::string &&	)->utf8_reader< std::basic_istream< Char > >

◆ utf8_reader() [2/4]

template<typename Char>

utf8_reader	(	std::basic_istream< Char > &	,
		std::string_view	)->utf8_reader< std::basic_istream< Char > >

◆ utf8_reader() [3/4]

template<typename Char>

utf8_reader	(	std::basic_string_view< Char >	,
		std::string &&	)->utf8_reader< std::basic_string_view< Char > >

◆ utf8_reader() [4/4]

template<typename Char>

utf8_reader	(	std::basic_string_view< Char >	,
		std::string_view	)->utf8_reader< std::basic_string_view< Char > >

◆ value() [1/2]

template<typename T>

value ( T ) ->value< impl::native_type_of< impl::remove_cvref< T > > >

◆ value() [2/2]

template<typename T>

value	(	T	,
		value_flags	)->value< impl::native_type_of< impl::remove_cvref< T > > >

Variable Documentation

◆ all_integral

template<typename... T>

bool all_integral = (std::is_integral_v<T> && ...)

inlineconstexpr

◆ allow_binary_integers

enum TOML_CLOSED_FLAGS_ENUM allow_binary_integers = (1ull << 6)

◆ allow_hexadecimal_integers

enum TOML_CLOSED_FLAGS_ENUM allow_hexadecimal_integers = (1ull << 8)

◆ allow_literal_strings

enum TOML_CLOSED_FLAGS_ENUM allow_literal_strings = (1ull << 2)

◆ allow_multi_line_strings

enum TOML_CLOSED_FLAGS_ENUM allow_multi_line_strings = (1ull << 3)

◆ allow_octal_integers

enum TOML_CLOSED_FLAGS_ENUM allow_octal_integers = (1ull << 7)

◆ allow_real_tabs_in_strings

enum TOML_CLOSED_FLAGS_ENUM allow_real_tabs_in_strings = (1ull << 4)

◆ allow_unicode_strings

enum TOML_CLOSED_FLAGS_ENUM allow_unicode_strings = (1ull << 5)

◆ always_false

template<typename...>

bool always_false = false

inlineconstexpr

◆ can_partially_represent_native

template<typename T>

bool can_partially_represent_native

inlineconstexpr

Initial value:

=

value_traits<T>::can_partially_represent_native

default_value_traits::can_partially_represent_native

static constexpr bool can_partially_represent_native

Definition toml.hpp:1839

◆ can_represent_native

template<typename T>

bool can_represent_native

inlineconstexpr

Initial value:

=

value_traits<T>::can_represent_native

default_value_traits::can_represent_native

static constexpr bool can_represent_native

Definition toml.hpp:1838

◆ charconv_buffer_length< double >

template<>

size_t charconv_buffer_length< double > = 64

inlineconstexpr

◆ charconv_buffer_length< float >

template<>

size_t charconv_buffer_length< float > = 64

inlineconstexpr

◆ charconv_buffer_length< int16_t >

template<>

size_t charconv_buffer_length< int16_t >

inlineconstexpr

Initial value:

=

6

◆ charconv_buffer_length< int32_t >

template<>

size_t charconv_buffer_length< int32_t >

inlineconstexpr

Initial value:

=

11

◆ charconv_buffer_length< int64_t >

template<>

size_t charconv_buffer_length< int64_t >

inlineconstexpr

Initial value:

=

20

◆ charconv_buffer_length< int8_t >

template<>

size_t charconv_buffer_length< int8_t > = 4

inlineconstexpr

◆ charconv_buffer_length< uint16_t >

template<>

size_t charconv_buffer_length< uint16_t >

inlineconstexpr

Initial value:

=

5

◆ charconv_buffer_length< uint32_t >

template<>

size_t charconv_buffer_length< uint32_t >

inlineconstexpr

Initial value:

=

10

◆ charconv_buffer_length< uint64_t >

template<>

size_t charconv_buffer_length< uint64_t >

inlineconstexpr

Initial value:

=

20

◆ charconv_buffer_length< uint8_t >

template<>

size_t charconv_buffer_length< uint8_t > = 3

inlineconstexpr

◆ control_char_escapes

std::string_view control_char_escapes[]

inlineconstexpr

◆ first_is_same

template<typename T, typename... U>

bool first_is_same = false

inlineconstexpr

◆ first_is_same< T, T, U... >

template<typename T, typename... U>

bool first_is_same< T, T, U... > = true

inlineconstexpr

◆ format_as_binary

enum TOML_OPEN_FLAGS_ENUM format_as_binary = 1

◆ format_as_hexadecimal

enum TOML_OPEN_FLAGS_ENUM format_as_hexadecimal = 3

◆ format_as_octal

enum TOML_OPEN_FLAGS_ENUM format_as_octal = 2

◆ format_flags

enum TOML_CLOSED_FLAGS_ENUM format_flags

strong

◆ indent_array_elements

enum TOML_CLOSED_FLAGS_ENUM indent_array_elements = (1ull << 10)

◆ indent_sub_tables

enum TOML_CLOSED_FLAGS_ENUM indent_sub_tables = (1ull << 9)

◆ indentation

enum TOML_CLOSED_FLAGS_ENUM indentation = indent_sub_tables | indent_array_elements

◆ is_array

template<typename T>

bool is_array = std::is_same_v<impl::remove_cvref<T>, array>

inlineconstexpr

◆ is_boolean

template<typename T>

bool is_boolean

inlineconstexpr

Initial value:

= std::is_same_v<            
    impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, 
    value<bool>>

◆ is_chronological

template<typename T>

bool is_chronological

inlineconstexpr

Initial value:

=

is_date<T> || is_time<T> || is_date_time<T>

is_date

constexpr bool is_date

Definition toml.hpp:2402

is_date_time

constexpr bool is_date_time

Definition toml.hpp:2412

is_time

constexpr bool is_time

Definition toml.hpp:2407

◆ is_constructible_or_convertible

template<typename T, typename ConvertFrom>

bool is_constructible_or_convertible

inlineconstexpr

Initial value:

=
    std::is_constructible_v<T, ConvertFrom> 
    || std::is_convertible_v<ConvertFrom, T>

◆ is_container

template<typename T>

bool is_container = is_table<T> || is_array<T>

inlineconstexpr

◆ is_cvref

template<typename T>

bool is_cvref

inlineconstexpr

Initial value:

=

std::is_reference_v<T> || std::is_const_v<T> || std::is_volatile_v<T>

◆ is_date

template<typename T>

bool is_date

inlineconstexpr

Initial value:

= std::is_same_v<               
    impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, 
    value<date>>

◆ is_date_time

template<typename T>

bool is_date_time

inlineconstexpr

Initial value:

= std::is_same_v<          
    impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, 
    value<date_time>>

◆ is_floating_point

template<typename T>

bool is_floating_point

inlineconstexpr

Initial value:

= std::is_same_v<     
    impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, 
    value<double>>

◆ is_integer

template<typename T>

bool is_integer

inlineconstexpr

Initial value:

= std::is_same_v<            
    impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, 
    value<int64_t>>

◆ is_key

template<typename T>

bool is_key

inlineconstexpr

Initial value:

=

std::is_same_v<impl::remove_cvref<T>, toml::key>

◆ is_key_or_convertible

template<typename T>

bool is_key_or_convertible

inlineconstexpr

Initial value:

=
    is_key<T> 
    || impl::is_constructible_or_convertible<toml::key, T>

◆ is_losslessly_convertible_to_native

template<typename T>

bool is_losslessly_convertible_to_native

inlineconstexpr

Initial value:

=

value_traits<T>::is_losslessly_convertible_to_native

default_value_traits::is_losslessly_convertible_to_native

static constexpr bool is_losslessly_convertible_to_native

Definition toml.hpp:1837

◆ is_native

template<typename T>

bool is_native = value_traits<T>::is_native

inlineconstexpr

◆ is_natively_one_of

template<typename T, typename... U>

bool is_natively_one_of = is_one_of<native_type_of<T>, U...>

inlineconstexpr

◆ is_node

template<typename T>

bool is_node

inlineconstexpr

Initial value:

=
    std::is_same_v<toml::node, impl::remove_cvref<T>> 
    || std::is_base_of_v<toml::node, impl::remove_cvref<T>>

◆ is_node_view

template<typename T>

bool is_node_view

inlineconstexpr

Initial value:

= impl::

is_one_of<impl::remove_cvref<T>, node_view<node>, node_view<const node>>

node_view

Definition toml.hpp:1525

◆ is_number

template<typename T>

bool is_number = is_integer<T> || is_floating_point<T>

inlineconstexpr

◆ is_one_of

template<typename T, typename... U>

bool is_one_of = (false || ... || std::is_same_v<T, U>)

inlineconstexpr

◆ is_string

template<typename T>

bool is_string

inlineconstexpr

Initial value:

= std::is_same_v<             
    impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, 
    value<std::string>>

◆ is_time

template<typename T>

bool is_time

inlineconstexpr

Initial value:

= std::is_same_v<               
    impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, 
    value<time>>

◆ is_value

template<typename T>

bool is_value

inlineconstexpr

Initial value:

=

is_string<T> || is_number<T> || is_boolean<T> || is_chronological<T>

is_number

constexpr bool is_number

Definition toml.hpp:2394

is_boolean

constexpr bool is_boolean

Definition toml.hpp:2397

is_string

constexpr bool is_string

Definition toml.hpp:2379

is_chronological

constexpr bool is_chronological

Definition toml.hpp:2417

◆ is_wide_string

template<typename T>

bool is_wide_string

inlineconstexpr

Initial value:

= is_one_of<
    std::decay_t<T>,
    const wchar_t *,
    wchar_t *,
    std::wstring_view,
    std::wstring>

◆ node_type_friendly_names

std::string_view node_type_friendly_names[]

inlineconstexpr

Initial value:

=
    {
        "none"sv,
        "table"sv,
        "array"sv,
        "string"sv,
        "integer"sv,
        "floating-point"sv,
        "boolean"sv,
        "date"sv,
        "time"sv,
        "date-time"sv
    }

◆ node_type_of

template<typename T>

node_type node_type_of

inlineconstexpr

Initial value:

=

node_type_getter<unwrap_node<remove_cvref<T>>>::value

node_type_getter

Definition toml.hpp:2338

◆ preserve_source_value_flags

value_flags preserve_source_value_flags

inlineconstexpr

Initial value:

=
    POXY_IMPLEMENTATION_DETAIL(
      value_flags{static_cast<std::underlying_type_t<value_flags>>(-1)})

◆ quote_dates_and_times

enum TOML_CLOSED_FLAGS_ENUM quote_dates_and_times = (1ull << 0)

◆ quote_infinities_and_nans

enum TOML_CLOSED_FLAGS_ENUM quote_infinities_and_nans = (1ull << 1)

◆ relaxed_float_precision

enum TOML_CLOSED_FLAGS_ENUM relaxed_float_precision = (1ull << 11)

◆ terse_key_value_pairs

enum TOML_CLOSED_FLAGS_ENUM terse_key_value_pairs = (1ull << 12)

◆ TOML_ABI_NAMESPACE_END

TOML_ABI_NAMESPACE_END

◆ TOML_ANON_NAMESPACE_END

TOML_ANON_NAMESPACE_END

◆ TOML_ANON_NAMESPACE_START

TOML_ANON_NAMESPACE_START

Initial value:

{
  template <typename T>
  inline constexpr size_t charconv_buffer_length = 0

◆ TOML_DISABLE_ARITHMETIC_WARNINGS

TOML_DISABLE_ARITHMETIC_WARNINGS

◆ TOML_DISABLE_SPAM_WARNINGS

TOML_DISABLE_SPAM_WARNINGS

◆ TOML_DISABLE_SUGGEST_ATTR_WARNINGS

TOML_DISABLE_SUGGEST_ATTR_WARNINGS

◆ TOML_DISABLE_SWITCH_WARNINGS

TOML_DISABLE_SWITCH_WARNINGS

◆ TOML_DISABLE_WARNINGS

TOML_DISABLE_WARNINGS

◆ TOML_ENABLE_WARNINGS

TOML_ENABLE_WARNINGS

◆ TOML_IMPL_NAMESPACE_END

TOML_IMPL_NAMESPACE_END

◆ TOML_IMPL_NAMESPACE_START

TOML_IMPL_NAMESPACE_START

Initial value:

{

using node_ptr = std::unique_ptr<node>

◆ TOML_NAMESPACE_END

TOML_NAMESPACE_END

◆ TOML_NAMESPACE_START

TOML_NAMESPACE_START

Initial value:

{
 
  template <typename T>
  using optional = std::optional<T>

◆ TOML_POP_WARNINGS

TOML_POP_WARNINGS

◆ TOML_PUSH_WARNINGS

TOML_PUSH_WARNINGS

◆ utf8_byte_order_mark

TOML_INTERNAL_LINKAGE constexpr auto utf8_byte_order_mark = "\xEF\xBB\xBF"sv

constexpr

◆ value_flags

enum TOML_OPEN_FLAGS_ENUM value_flags

strong

◆ value_retrieval_is_nothrow

template<typename T>

bool value_retrieval_is_nothrow

inlineconstexpr

Initial value:

=
    !std::is_same_v<remove_cvref<T>, std::string>
 
    && !is_wide_string<T>

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ advance_and_return_if_error

◆ advance_and_return_if_error_or_eof

◆ assert_not_eof

◆ assert_not_error

◆ INCLUDE_TOMLPLUSPLUS_H

◆ is_eof

◆ is_error

◆ parse_error_break

◆ POXY_IMPLEMENTATION_DETAIL

◆ push_parse_scope

◆ push_parse_scope_1

◆ push_parse_scope_2

◆ return_after_error

◆ return_if_eof

◆ return_if_error

◆ return_if_error_or_eof

◆ set_error_and_return

◆ set_error_and_return_default

◆ set_error_and_return_if_eof

◆ TOML_ABI_NAMESPACE_BOOL

◆ TOML_ABI_NAMESPACE_END

◆ TOML_ABI_NAMESPACE_START

◆ TOML_ABI_NAMESPACES

◆ TOML_ABSTRACT_INTERFACE

◆ TOML_ALWAYS_INLINE

◆ TOML_ANON_NAMESPACE

◆ TOML_ANON_NAMESPACE_END

◆ TOML_ANON_NAMESPACE_START

◆ TOML_ARCH_AMD64

◆ TOML_ARCH_ARM

◆ TOML_ARCH_ARM32

◆ TOML_ARCH_ARM64

◆ TOML_ARCH_BITNESS

◆ TOML_ARCH_ITANIUM

◆ TOML_ARCH_X64

◆ TOML_ARCH_X86

◆ TOML_ASSERT

◆ TOML_ASSERT_ASSUME

◆ TOML_ASSUME

◆ TOML_ASYMMETRICAL_EQUALITY_OPS

◆ TOML_ATTR

◆ TOML_CALLCONV

◆ TOML_CLANG

◆ TOML_CLOSED_ENUM

◆ TOML_CLOSED_FLAGS_ENUM

◆ TOML_COMPILER_HAS_EXCEPTIONS

◆ TOML_COMPILER_HAS_RTTI

◆ TOML_CONCAT

◆ TOML_CONCAT_1

◆ TOML_CONST

◆ TOML_CONST_GETTER

◆ TOML_CONST_INLINE_GETTER

◆ TOML_CONSTRAINED_TEMPLATE

◆ TOML_CPP [1/2]

◆ TOML_CPP [2/2]

◆ TOML_CUDA

◆ TOML_DECLSPEC

◆ TOML_DELETE_DEFAULTS

◆ TOML_DISABLE_ARITHMETIC_WARNINGS

◆ TOML_DISABLE_CODE_ANALYSIS_WARNINGS

◆ TOML_DISABLE_SPAM_WARNINGS

◆ TOML_DISABLE_SUGGEST_ATTR_WARNINGS

◆ TOML_DISABLE_SWITCH_WARNINGS

◆ TOML_DISABLE_WARNINGS

◆ TOML_DOXYGEN

◆ TOML_EMPTY_BASES

◆ TOML_ENABLE_FLOAT16

◆ TOML_ENABLE_FORMATTERS

◆ TOML_ENABLE_IF

◆ TOML_ENABLE_PARSER

◆ TOML_ENABLE_SIMD

◆ TOML_ENABLE_UNRELEASED_FEATURES

◆ TOML_ENABLE_WARNINGS