Introduction on toml11

parsing files

Mon, 01 Jan 0001 00:00:00 +0000

Parsing Files and Strings #

In toml11, you can parse files, strings, and byte arrays using toml::parse or toml::try_parse.

Upon success, these functions return a toml::value. Although the parsed file is always a table, the return type is not toml::table. This is because toml::value contains metadata about the file, whereas toml::table is merely an alias for std::unordered_map<std::string, toml::value>. To include metadata, a toml::value is returned instead of a toml::table. The toml::value corresponding to the root of the file will always hold a table_type.

getting values

Mon, 01 Jan 0001 00:00:00 +0000

Retrieving Values #

This section explains how to access the values stored in toml::value.

Accessing Values Using Member Functions #

`is_something` and `as_something` #

toml::value has member functions like is_boolean() and is_integer() which allow you to check the type of the stored value.

Additionally, it has member functions like as_boolean() and as_integer() that allow you to access the value of that type.

For a complete list, refer to the toml::value reference.

error message

Mon, 01 Jan 0001 00:00:00 +0000

Outputting Error Messages #

toml11 provides error messages that include location information within the file when using functions like toml::parse, toml::get<T>/find<T>, and as_integer(), among others.

For instance, if a syntax error in an integer is detected during parsing, an error message might look like this:

[error] bad integer: `_` must be surrounded by digits
 --> internal string at line 64 in file main.cpp
 |
 1 | a = 123__456
 | ^-- invalid underscore
Hint: valid : -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755
Hint: invalid: _42, 1__000, 0123

Or, if a type different from the one actually stored is requested:

serializing values

Mon, 01 Jan 0001 00:00:00 +0000

Outputting TOML Files #

Using toml::format, you can convert a toml::value to a string.

#include <toml.hpp>
#include <cassert>

int main()
{
 const toml::value v(toml::table{
 {"a", 42},
 {"b", "foo"},
 });
 const std::string s = toml::format(v);

 const toml::value u = toml::parse_str(s);

 assert(u.at("a").as_integer() == 42);
 assert(u.at("b").as_string() == "foo");

 return 0;
}

If the toml::value contains a table_type, it is interpreted as the root table of the file.

If a toml::value containing anything other than table_type is passed, only that value is formatted.

configuring types

Mon, 01 Jan 0001 00:00:00 +0000

Customizing Types #

The toml::value class uses std::int64_t for integer_type and std::unordered_map<key_type, value_type> for table_type.

However, in some cases, you may want to use boost::multiprecision::int128_t or std::map.

To accommodate this, toml::value is implemented with template parameters that allow you to change the stored types.

Just as std::string is actually an alias for std::basic_string<char, std::char_traits<char>, std::allocator<char>>, toml::value is an alias for toml::basic_value<toml::type_config>.

Here, we will explain the types contained in toml::type_config and how to define a different config type.

toml literal

Mon, 01 Jan 0001 00:00:00 +0000

`_toml` Literal #

With the ""_toml literal, you can format TOML files inline.

#include <toml.hpp>

int main()
{
 using namespace toml::literals::toml_literals;

 const auto v = "a = 42"_toml;

 assert(v.at("a").as_integer() == 42);

 return 0;
}

When including line breaks, raw string literals come in handy.

#include <toml.hpp>

int main()
{
 using namespace toml::literals::toml_literals;

 const auto v = R"(
 a = 42
 b = "foo"
 )"_toml;

 assert(v.at("a").as_integer() == 42);
 assert(v.at("b").as_string() == "foo");

 return 0;
}

If a value is written on its own, that value is returned.

toml spec

Mon, 01 Jan 0001 00:00:00 +0000

TOML Language Version #

You can specify the version of the TOML language and individual feature flags to use with toml::parse or toml::format through toml::spec.

Specifying TOML Version #

You can construct a toml::spec from toml::semantic_version.

#include <toml.hpp>

int main()
{
 toml::spec spec(toml::semantic_version(1, 1, 0));
 return 0;
}

However, to make this shorter, the toml::spec::v() function is provided.

#include <toml.hpp>

int main()
{
 toml::spec spec = toml::spec::v(1, 1, 0);
 return 0;
}

If not specified explicitly, toml::spec::default_version() is used to construct with default values.

extension

Mon, 01 Jan 0001 00:00:00 +0000

TOML Language Extensions #

The TOML language is currently at version v1.0.0, but several new features have been discussed and merged, with ongoing discussions for v1.1.0.

Among the proposed features, some were deemed to have limited use cases, some faced implementation challenges in their proposed form, and others were not adopted at all.

In toml11, we have experimentally implemented a selection of these features. Please note that these features are supported in toml11 but are not supported by other parsers and are unlikely to be supported in the future.

color.hpp

Mon, 01 Jan 0001 00:00:00 +0000

color.hpp #

In color.hpp, functions related to colorizing error messages are defined.

Colors are specified using ANSI escape code. In terminals or other output destinations that do not support ANSI escape code, the output may become difficult to read.

Macros #

`TOML11_COLORIZE_ERROR_MESSAGE` #

If this macro is defined during compilation (-DTOML11_COLORIZE_ERROR_MESASGE), error messages are colored by default.

If not defined, colors are not applied by default. You need to specify them using toml::color::enable().

comments.hpp

Mon, 01 Jan 0001 00:00:00 +0000

comments.hpp #

In comments.hpp, comment containers are provided.

`toml::preserve_comments` #

preserve_comments is a container that preserves comments.

It has all the member functions of std::vector<std::string>.

Comments are preserved as std::string. If the comment does not start with #, it will be prefixed with # during output. However, this prefixing is not done when adding comments to the container.

Spaces are not automatically added, so if you want a space immediately after #, either start the comment with a space or pass the comment with #.

conversion.hpp

Mon, 01 Jan 0001 00:00:00 +0000

conversion.hpp #

Provides macros to automatically define conversion functions for supporting user-defined types with toml::get and toml::find.

TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(NAME, ...)

Example #

namespace foo
{
struct Foo
{
 std::string s;
 double d;
 int i;
};
} // foo

TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i)

datetime.hpp

Mon, 01 Jan 0001 00:00:00 +0000

datetime.hpp #

Defines a class that stores date and time information used in TOML’s datetime.

`enum class month_t` #

Enum class to specify months.

Due to its relationship with std::tm, local_date treats January as 0. To avoid confusion, month_t allows specification of months by their names.

namespace toml
{
enum class month_t : std::uint8_t
{
 Jan = 0,
 Feb = 1,
 Mar = 2,
 Apr = 3,
 May = 4,
 Jun = 5,
 Jul = 6,
 Aug = 7,
 Sep = 8,
 Oct = 9,
 Nov = 10,
 Dec = 11
};
}

`local_date` #

local_date holds a date.

error_info.hpp

Mon, 01 Jan 0001 00:00:00 +0000

error_info.hpp #

In error_info.hpp, definitions for error_info and functions to format it are provided.

`toml::error_info` #

namespace toml
{
struct error_info
{
 error_info(std::string t, source_location l, std::string m, std::string s = "");
 error_info(std::string t, std::vector<std::pair<source_location, std::string>> l, std::string s = "");

 std::string const& title() const noexcept;
 std::string & title() noexcept;

 std::vector<std::pair<source_location, std::string>> const& locations() const noexcept;
 void add_locations(source_location loc, std::string msg) noexcept;

 std::string const& suffix() const noexcept;
 std::string & suffix() noexcept;
};

template<typename ... Ts>
error_info make_error_info(
 std::string title, source_location loc, std::string msg, Ts&& ... tail);

std::string format_error(const std::string& errkind, const error_info& err);
std::string format_error(const error_info& err);

template<typename ... Ts>
std::string format_error(std::string title,
 source_location loc, std::string msg, Ts&& ... tail);

std::ostream& operator<<(std::ostream& os, const error_info& e);
}

Member Functions #

Constructor (`title, loc, msg, suffix`) #

Constructs error_info with specified title, location information loc, message msg, and optional suffix.

exception.hpp

Mon, 01 Jan 0001 00:00:00 +0000

exception.hpp #

`toml::exception` #

Base class for exception types defined in toml11.

namespace toml
{
struct exception : public std::exception
{
 public:
 virtual ~exception() noexcept override = default;
 virtual const char* what() const noexcept override {return "";}
};
} // toml

Member Functions #

Destructor #

virtual ~exception() noexcept override = default;

Override when derived.

`what` #

virtual const char* what() const noexcept override {return "";}

Returns the error message. Override when derived.

find.hpp

Mon, 01 Jan 0001 00:00:00 +0000

find.hpp #

This function searches for a value in a toml::value and performs type conversion if necessary.

toml::value can change the type it stores, and toml::find accommodates these types. Technically, all functions use toml::basic_value<TC>. However, for simplicity, we refer to it as toml::value in explanations unless a distinction is necessary. In the documentation, if the template parameter TC changes the type, assume that types like toml::value::integer_type will also change accordingly.

`toml::find` #

Overview #

toml::find uses template arguments for the type you want to retrieve and function arguments for the key of the value you want to find.

format.hpp

Mon, 01 Jan 0001 00:00:00 +0000

format.hpp #

Defines structures and enumerations related to formatting information for toml::value.

`indent_char` #

An enumeration representing the indentation character choice.

enum class indent_char : std::uint8_t
{
 space, // use space
 tab, // use tab
 none // no indent
};
std::ostream& operator<<(std::ostream& os, const indent_char& c);
std::string to_string(const indent_char);

Choosing none means no indentation is used, regardless of the value in super tables.

If both space and tab are specified within the serializable value, the behavior is unspecified; typically, the unspecified indentation character appears.

from.hpp

Mon, 01 Jan 0001 00:00:00 +0000

from.hpp #

Defines a struct used for conversion from toml::value in toml::get and toml::find.

You can achieve the same functionality by adding a from_toml member function, but for classes where you cannot add member functions, use from<T>.

This file does not provide specific implementations. Please specialize this struct when using.

namespace toml
{

template<typename T>
struct from;

} // toml

Example #

namespace extlib
{
struct foo
{
 int a;
 std::string b;
};
} // extlib

#include <toml11/from.hpp>

namespace toml
{
template<>
struct from<extlib::foo>
{
 template<typename TC>
 static extlib::foo from_toml(const toml::basic_value<TC>& v)
 {
 return extlib::foo{toml::find<int>(v, "a"), toml::find<std::string>(v, "b")};
 }
};
} // toml

get.hpp

Mon, 01 Jan 0001 00:00:00 +0000

get.hpp #

These are functions for extracting values from toml::value and performing type conversions if necessary.

toml::value can change the type it stores, and toml::get accommodates these types. Technically, all functions use toml::basic_value<TC>. However, for simplicity, we refer to it as toml::value in explanations unless a distinction is necessary. In the documentation, if the template parameter TC changes the type, assume that types like toml::value::integer_type will also change accordingly.

`toml::get<T>` #

Overview #

Generally, toml::get behaves as follows: You specify T as in toml::get<int>(v).

into.hpp

Mon, 01 Jan 0001 00:00:00 +0000

into.hpp #

Defines a struct used for conversion from user-defined types into toml::value constructors.

You can achieve the same functionality by adding an into_toml member function, but for classes where you cannot add member functions, use into<T>.

This file does not provide specific implementations. Please specialize this struct when using.

namespace toml
{

template<typename T>
struct into;

} // toml

Example #

namespace extlib
{
struct foo
{
 int a;
 std::string b;
};
} // extlib

#include <toml11/into.hpp>

namespace toml
{
template<>
struct into<extlib::foo>
{
 template<typename TC>
 static toml::basic_value<TC> into_toml(const extlib::foo& f)
 {
 using value_type = toml::basic_value<TC>;
 using table_type = typename value_type::table_type;
 return value_type(table_type{{"a", f.a}, {"b", f.b}});
 }
};
} // toml

literal.hpp

Mon, 01 Jan 0001 00:00:00 +0000

literal.hpp #

In literal.hpp, the _toml literal is defined.

The _toml literal parses string literals into toml::value.

namespace toml
{
inline namespace literals
{
inline namespace toml_literals
{
toml::value operator"" _toml(const char* str, std::size_t len);
toml::value operator"" _toml(const char8_t* str, std::size_t len); // Available in C++20 and later
} // toml_literals
} // literals
} // toml

Free Functions #

`operator"" _toml(const char*)` #

toml::value operator"" _toml(const char* str, std::size_t len);

Converts a string literal into a toml::value by parsing it.

ordered_map.hpp

Mon, 01 Jan 0001 00:00:00 +0000

ordered_map.hpp #

Defines toml::ordered_map, which is used to maintain the order of values in a file.

`class ordered_map` #

namespace toml
{
template<typename Key, typename Val, typename Cmp = std::equal_to<Key>,
 typename Allocator = std::allocator<std::pair<Key, Val>>>
class ordered_map;
}

The ordered_map is a map type that preserves the insertion order of values, allowing iteration in that order.

As a linear container, searches require O(n) time relative to the number of elements. Use this when search operations are infrequent and maintaining the order of values is important.

parser.hpp

Mon, 01 Jan 0001 00:00:00 +0000

parser.hpp #

Defines functions for parsing files or strings and the exceptions they use.

While parse throws an exception on failure, try_parse returns error information.

`parse` #

Parses the content of a given file and returns a toml::basic_value.

In case of failure, toml::syntax_error is thrown.

The type information of basic_value is provided by a template, and the TOML language version is specified by toml::spec.

`parse(std::string filename, toml::spec)` #

namespace toml
{
template<typename TC = type_config>
basic_value<TC>
parse(std::string fname,
 spec s = spec::default_version());
}

Parses the content of the given filename.

result.hpp

Mon, 01 Jan 0001 00:00:00 +0000

result.hpp #

result.hpp defines the result type, which can hold either a success value or a failure value.

This is used as the return type for toml::try_parse, which does not throw exceptions.

success #

A type that holds a success value.

namespace toml
{
template<typename T>
struct success
{
 using value_type = T;

 explicit success(value_type v);

 ~success() = default;
 success(const success&) = default;
 success(success&&) = default;
 success& operator=(const success&) = default;
 success& operator=(success&&) = default;

 template<typename U>
 explicit success(U&& v);
 template<typename U>
 explicit success(success<U> v);

 value_type& get() noexcept;
 value_type const& get() const noexcept;
};

template<typename T>
success<typename std::decay<T>::type> ok(T&& v);
template<std::size_t N>
success<std::string> ok(const char (&literal)[N])
}

Member Types #

using value_type = T;

The type of the success value.

serializer.hpp

Mon, 01 Jan 0001 00:00:00 +0000

serializer.hpp #

`format` #

Serializes the data.

namespace toml
{
template<typename TC>
std::string format(const basic_value<TC>& v,
 const spec s = spec::default_version());
template<typename TC>
std::string format(const typename basic_value<TC>::key_type& k,
 const basic_value<TC>& v,
 const spec s = spec::default_version());
template<typename TC>
std::string format(const std::vector<typename basic_value<TC>::key_type>& ks,
 const basic_value<TC>& v,
 const spec s = spec::default_version());
}

If there’s a conflict between the format information and the spec, for example, when using v1.0.0 with table_format::multiline_oneline, the spec takes precedence.

source_location.hpp

Mon, 01 Jan 0001 00:00:00 +0000

source_location.hpp #

source_location.hpp defines a class representing a specific area within a TOML file.

This class is used to represent problematic areas in error messages.

`toml::source_location` #

source_location is a class representing a specific area within a TOML file.

namespace toml
{
struct source_location
{
 public:

 explicit source_location(/* implementation-defined */);
 ~source_location() = default;
 source_location(source_location const&) = default;
 source_location(source_location &&) = default;
 source_location& operator=(source_location const&) = default;
 source_location& operator=(source_location &&) = default;

 bool is_ok() const noexcept;
 std::size_t length() const noexcept;

 std::size_t first_line_number() const noexcept;
 std::size_t first_column_number() const noexcept;
 std::size_t last_line_number() const noexcept;
 std::size_t last_column_number() const noexcept;

 std::string const& file_name() const noexcept;

 std::size_t num_lines() const noexcept;

 std::string const& first_line() const;
 std::string const& last_line() const;

 std::vector<std::string> const& lines() const noexcept;
};

template<typename ... Ts>
std::string format_location(const source_location& loc, const std::string& msg, const Ts& ... locs_and_msgs);
} //toml

Member Functions #

Constructor #

explicit source_location(/* implementation-defined */);

toml::source_location can only be constructed via toml::parse or the _toml literal.

spec.hpp

Mon, 01 Jan 0001 00:00:00 +0000

spec.hpp #

spec.hpp defines classes for specifying the version of TOML.

`toml::semantic_version` #

semantic_version is a class that stores version information.

namespace toml
{
struct semantic_version
{
 constexpr semantic_version(std::uint32_t mjr, std::uint32_t mnr, std::uint32_t p) noexcept;

 std::uint32_t major;
 std::uint32_t minor;
 std::uint32_t patch;
};

constexpr semantic_version
make_semver(std::uint32_t major, std::uint32_t minor, std::uint32_t patch) noexcept;

constexpr bool operator==(const semantic_version&, const semantic_version&) noexcept;
constexpr bool operator!=(const semantic_version&, const semantic_version&) noexcept;
constexpr bool operator< (const semantic_version&, const semantic_version&) noexcept;
constexpr bool operator<=(const semantic_version&, const semantic_version&) noexcept;
constexpr bool operator> (const semantic_version&, const semantic_version&) noexcept;
constexpr bool operator>=(const semantic_version&, const semantic_version&) noexcept;

std::ostream& operator<<(std::ostream& os, const semantic_version& ver);
} //toml

Member Functions #

Constructor #

constexpr semantic_version(std::uint32_t mjr, std::uint32_t mnr, std::uint32_t p) noexcept;

Constructs a semantic_version instance with the specified major, minor, and patch version numbers.

toml_fwd.hpp

Mon, 01 Jan 0001 00:00:00 +0000

toml_fwd.hpp #

toml_fwd.hpp contains forward declarations of structures defined in toml11 and macro definitions.

When only forward declarations of toml11 structures are needed and implementation is not required, including toml_fwd.hpp instead of toml.hpp can reduce compilation time.

Since this file only contains forward declarations, you cannot use toml::table, defined as toml::basic_value<toml::type_config>::table_type, and similarly defined toml::array. This is because they require the implementation of basic_value.

This header file and toml.hpp are located under ${TOML11_INCLUDE_DIR}/, while other header files are located under ${TOML11_INCLUDE_DIR}/toml11/.

toml.hpp

Mon, 01 Jan 0001 00:00:00 +0000

toml.hpp #

toml.hpp includes all other headers.

This allows access to all features of toml11.

This header file and toml_fwd.hpp are located under ${TOML11_INCLUDE_DIR}/, while other header files are located under ${toml11_include_dir}/toml11/.

types.hpp

Mon, 01 Jan 0001 00:00:00 +0000

types.hpp #

This document defines classes that specifies type information.

`type_config` #

type_config is a type that encapsulates parameters given to toml::basic_value.

When using different types within toml::basic_value<T>, you need to define and pass this type separately. All elements listed are required.

If you use numerical types that cannot use standard stream operators, define and replace the equivalents for read_int and read_float.

namespace toml
{
struct type_config
{
 using comment_type = preserve_comments;

 using boolean_type = bool;
 using integer_type = std::int64_t;
 using floating_type = double;
 using string_type = std::string;

 template<typename T>
 using array_type = std::vector<T>;
 template<typename K, typename T>
 using table_type = std::unordered_map<K, T>;

 static result<integer_type, error_info>
 parse_int(const std::string& str, const source_location src, const std::uint8_t base);

 static result<floating_type, error_info>
 parse_float(const std::string& str, const source_location src, const bool is_hex);
};

using value = basic_value<type_config>;
using table = typename value::table_type;
using array = typename value::array_type;

} // toml

`static` Member Functions #

`parse_int(str, src, base)` #

static result<integer_type, error_info>
parse_int(const std::string& str, const source_location src, const std::uint8_t base);

If you use a type as integer_type that cannot utilize standard stream operators, implement this function. Otherwise, use read_int described later.

value_t.hpp

Mon, 01 Jan 0001 00:00:00 +0000

value_t.hpp #

`value_t` #

value_t is used to handle the type information of toml::value.

namespace toml
{
enum class value_t : std::uint8_t
{
 empty = 0,
 boolean = 1,
 integer = 2,
 floating = 3,
 string = 4,
 offset_datetime = 5,
 local_datetime = 6,
 local_date = 7,
 local_time = 8,
 array = 9,
 table = 10
};

std::ostream& operator<<(std::ostream& os, value_t t);
std::string to_string(value_t t);
} // toml

Non-member Functions #

Stream Operator #

std::ostream& operator<<(std::ostream& os, value_t t);

Outputs the string representation of the value_t to the stream.

value.hpp

Mon, 01 Jan 0001 00:00:00 +0000

value.hpp #

value.hpp defines basic_value.

`toml::basic_value` #

basic_value is a class that stores TOML values.

namespace toml
{
template <class TypeConfig>
class basic_value;

// Defined in types.hpp
// using value = basic_value<type_config>;
// using table = typename basic_value<type_config>::table_type;
// using array = typename basic_value<type_config>::array_type;

template<typename TC>
bool operator==(const basic_value<TC>&, const basic_value<TC>&);
template<typename TC>
bool operator!=(const basic_value<TC>&, const basic_value<TC>&);
template<typename TC>
bool operator< (const basic_value<TC>&, const basic_value<TC>&);
template<typename TC>
bool operator<=(const basic_value<TC>&, const basic_value<TC>&);
template<typename TC>
bool operator> (const basic_value<TC>&, const basic_value<TC>&);
template<typename TC>
bool operator>=(const basic_value<TC>&, const basic_value<TC>&);
} //toml

Member Types #

The following member types are defined.

version.hpp

Mon, 01 Jan 0001 00:00:00 +0000

version.hpp #

In version.hpp, macros related to the version information of toml11 are defined.

Macros #

`TOML11_VERSION_MAJOR` #

The major version of toml11.

`TOML11_VERSION_MINOR` #

The minor version of toml11.

`TOML11_VERSION_PATCH` #

The patch version of toml11.

Function #

`license_notice` #

namespace toml
{
const char* license_notice() noexcept;
}

Returns the license notice.

Provided for convenience when redistributing without source code.

visit.hpp

Mon, 01 Jan 0001 00:00:00 +0000

visit.hpp #

In visit.hpp, toml::visit is defined.

`toml::visit` #

Functions #

namespace toml
{
template<typename Visitor, typename ... Args>
/* Return value when Visitor is called with a value of basic_value<TC> */
visit(Visitor&& visitor, Args&& ... args);
}

toml::visit calls the overload of Visitor corresponding to the type held by basic_value<TC>, and returns the result.

Requirements #

Visitor must be a function or function object callable with any type held by basic_value<TC>.

Introduction on toml11

parsing files

Parsing Files and Strings #

getting values

Retrieving Values #

Accessing Values Using Member Functions #

is_something and as_something #

error message

Outputting Error Messages #

serializing values

Outputting TOML Files #

configuring types

Customizing Types #

toml literal

_toml Literal #

toml spec

TOML Language Version #

Specifying TOML Version #

extension

TOML Language Extensions #

color.hpp

color.hpp #

Macros #

TOML11_COLORIZE_ERROR_MESSAGE #

comments.hpp

comments.hpp #

toml::preserve_comments #

conversion.hpp

conversion.hpp #

Example #

Related #

datetime.hpp

datetime.hpp #

enum class month_t #

local_date #

error_info.hpp

error_info.hpp #

toml::error_info #

Member Functions #

Constructor (title, loc, msg, suffix) #

exception.hpp

exception.hpp #

toml::exception #

Member Functions #

Destructor #

what #

find.hpp

find.hpp #

toml::find #

Overview #

format.hpp

format.hpp #

indent_char #

from.hpp

from.hpp #

Example #

Related #

get.hpp

get.hpp #

toml::get<T> #

Overview #

into.hpp

into.hpp #

Example #

Related #

literal.hpp

literal.hpp #

Free Functions #

operator"" _toml(const char*) #

ordered_map.hpp

ordered_map.hpp #

class ordered_map #

parser.hpp

parser.hpp #

parse #

parse(std::string filename, toml::spec) #

result.hpp

result.hpp #

success #

Member Types #

`is_something` and `as_something` #

`_toml` Literal #

`TOML11_COLORIZE_ERROR_MESSAGE` #

`toml::preserve_comments` #

`enum class month_t` #

`local_date` #

`toml::error_info` #

Constructor (`title, loc, msg, suffix`) #

`toml::exception` #

`what` #

`toml::find` #

`indent_char` #

`toml::get<T>` #

`operator"" _toml(const char*)` #

`class ordered_map` #

`parse` #

`parse(std::string filename, toml::spec)` #

`format` #

`toml::source_location` #

`toml::semantic_version` #

`type_config` #

`static` Member Functions #

`parse_int(str, src, base)` #

`value_t` #

`toml::basic_value` #

`TOML11_VERSION_MAJOR` #

`TOML11_VERSION_MINOR` #

`TOML11_VERSION_PATCH` #

`license_notice` #

`toml::visit` #