toml::table class

A TOML table.

The interface of this type is modeled after std::map, with some additional considerations made for the heterogeneous nature of a TOML table.

toml::table tbl = toml::parse(R"(

    [animals]
    cats = [ "tiger", "lion", "puma" ]
    birds = [ "macaw", "pigeon", "canary" ]
    fish = [ "salmon", "trout", "carp" ]

)"sv);

// operator[] retrieves node-views
std::cout << "cats: " << tbl["animals"]["cats"] << "\n";
std::cout << "fish[1]: " << tbl["animals"]["fish"][1] << "\n";

// at_path() does fully-qualified "toml path" lookups
std::cout << "cats: " << tbl.at_path("animals.cats") << "\n";
std::cout << "fish[1]: " << tbl.at_path("animals.fish[1]") << "\n";

cats: ['tiger', 'lion', 'puma']
fish[1] : 'trout'
cats : ['tiger', 'lion', 'puma']
fish[1] : 'trout'

Base classes

class node: A TOML node.

Constructors, destructors, conversion operators

table() noexcept: Default constructor.
table(const table&): Copy constructor.
table(table&& other) noexcept: Move constructor.
table(std::initializer_list<impl::table_init_pair> kvps) explicit: Constructs a table with one or more initial key-value pairs.

Public functions

auto operator=(const table&) -> table&: Copy-assignment operator.
auto operator=(table&& rhs) -> table& noexcept: Move-assignment operator.

Equality

auto operator!=(const table& lhs, const table& rhs) -> bool noexcept: Inequality operator.
auto operator==(const table& lhs, const table& rhs) -> bool noexcept: Equality operator.

Erasure

void clear() noexcept: Removes all key-value pairs from the table.
auto erase(iterator pos) -> iterator noexcept: Removes the specified key-value pair from the table.
auto erase(const_iterator pos) -> iterator noexcept: Removes the specified key-value pair from the table (const iterator overload).
auto erase(const_iterator begin, const_iterator end) -> iterator noexcept: Removes the key-value pairs in the range [first, last) from the table.
auto erase(std::string_view key) -> size_t noexcept: Removes the value with the given key from the table.
auto erase(std::wstring_view key) -> size_t: Removes the value with the given key from the table.
auto prune(bool recursive = true) & -> table& noexcept: Removes empty child arrays and tables.
auto prune(bool recursive = true) && -> table&& noexcept: Removes empty child arrays and tables (rvalue overload).

Insertion and Emplacement

template <typename ValueType = void, typename KeyType, typename... ValueArgs> auto emplace(KeyType&& key, ValueArgs && ... args) -> std::pair<iterator, bool>: Emplaces a new value at a specific key if one did not already exist.
template <typename ValueType = void, typename KeyType, typename... ValueArgs> auto emplace_hint(const_iterator hint, KeyType&& key, ValueArgs && ... args) -> iterator: Emplaces a new value at a specific key if one did not already exist.
template <typename KeyType, typename ValueType> auto insert(KeyType&& key, ValueType&& val, value_flags flags = preserve_source_value_flags) -> std::pair<iterator, bool>: Inserts a new value at a specific key if one did not already exist.
template <typename Iter> void insert(Iter begin, Iter end, value_flags flags = preserve_source_value_flags): Inserts a series of key-value pairs into the table.
template <typename KeyType, typename ValueType> auto insert_or_assign(KeyType&& key, ValueType&& val, value_flags flags = preserve_source_value_flags) -> std::pair<iterator, bool>: Inserts or assigns a value at a specific key.

Iteration

using const_iterator = toml::const_table_iterator: A BidirectionalIterator for iterating over const key-value pairs in a toml::table.
using iterator = toml::table_iterator: A BidirectionalIterator for iterating over key-value pairs in a toml::table.
auto begin() -> iterator noexcept: Returns an iterator to the first key-value pair.
auto begin() const -> const_iterator noexcept: Returns an iterator to the first key-value pair.
auto cbegin() const -> const_iterator noexcept: Returns an iterator to the first key-value pair.
auto cend() const -> const_iterator noexcept: Returns an iterator to one-past-the-last key-value pair.
auto end() -> iterator noexcept: Returns an iterator to one-past-the-last key-value pair.
auto end() const -> const_iterator noexcept: Returns an iterator to one-past-the-last key-value pair.
template <typename Func> auto for_each(Func&& visitor) & -> table& noexcept(…): Invokes a visitor on each key-value pair in the table.
template <typename Func> auto for_each(Func&& visitor) && -> table&& noexcept(…): Invokes a visitor on each key-value pair in the table (rvalue overload).
template <typename Func> auto for_each(Func&& visitor) const & -> const table& noexcept(…): Invokes a visitor on each key-value pair in the table (const lvalue overload).
template <typename Func> auto for_each(Func&& visitor) const && -> const table&& noexcept(…): Invokes a visitor on each key-value pair in the table (const rvalue overload).

Metadata

auto is_inline() const -> bool noexcept: Returns true if this table is an inline table.
void is_inline(bool val) noexcept: Sets whether this table is a TOML inline table.
auto source() const -> const source_region& noexcept: Returns the source region responsible for generating this node during parsing.

Node views

auto at_path(std::string_view path) -> node_view<node> noexcept: Returns a view of the subnode matching a fully-qualified "TOML path".
auto at_path(std::string_view path) const -> node_view<const node> noexcept: Returns a const view of the subnode matching a fully-qualified "TOML path".
auto at_path(const toml::path& path) -> node_view<node> noexcept: Returns a view of the subnode matching a fully-qualified "TOML path".
auto at_path(const toml::path& path) const -> node_view<const node> noexcept: Returns a const view of the subnode matching a fully-qualified "TOML path".
auto at_path(std::wstring_view path) -> node_view<node>: Returns a view of the subnode matching a fully-qualified "TOML path".
auto at_path(std::wstring_view path) const -> node_view<const node>: Returns a const view of the subnode matching a fully-qualified "TOML path".
operator node_view<const node>() const explicit noexcept: Creates a node_view pointing to this node (const overload).
operator node_view<node>() explicit noexcept: Creates a node_view pointing to this node.
auto operator[](std::string_view key) -> node_view<node> noexcept: Gets a node_view for the selected value.
auto operator[](std::string_view key) const -> node_view<const node> noexcept: Gets a node_view for the selected value (const overload).
auto operator[](std::wstring_view key) -> node_view<node>: Gets a node_view for the selected value.
auto operator[](std::wstring_view key) const -> node_view<const node>: Gets a node_view for the selected value (const overload).
auto operator[](const toml::path& path) -> node_view<node> noexcept: Returns a const view of the subnode matching a fully-qualified "TOML path".
auto operator[](const toml::path& path) const -> node_view<const node> noexcept: Returns a const view of the subnode matching a fully-qualified "TOML path".

Searching

auto contains(std::string_view key) const -> bool noexcept: Returns true if the table contains a node at the given key.
auto contains(std::wstring_view key) const -> bool: Returns true if the table contains a node at the given key.
auto find(std::string_view key) -> iterator noexcept: Gets an iterator to the node at a specific key.
auto find(std::string_view key) const -> const_iterator noexcept: Gets an iterator to the node at a specific key (const overload)
auto find(std::wstring_view key) -> iterator: Gets an iterator to the node at a specific key.
auto find(std::wstring_view key) const -> const_iterator: Gets an iterator to the node at a specific key (const overload).
auto lower_bound(std::string_view key) -> iterator noexcept: Returns an iterator to the first key-value pair with key that is not less than the given key.
auto lower_bound(std::string_view key) const -> const_iterator noexcept: Returns a const iterator to the first key-value pair with key that is not less than the given key.
auto lower_bound(std::wstring_view key) -> iterator: Returns an iterator to the first key-value pair with key that is not less than the given key.
auto lower_bound(std::wstring_view key) const -> const_iterator: Returns a const iterator to the first key-value pair with key that is not less than the given key.

Size and Capacity

auto empty() const -> bool noexcept: Returns true if the table is empty.
auto size() const -> size_t noexcept: Returns the number of key-value pairs in the table.

Type casts

template <typename T> auto as() -> impl::wrap_node<T>* noexcept: Gets a pointer to the node as a more specific node type.
template <typename T> auto as() const -> const impl::wrap_node<T>* noexcept: Gets a pointer to the node as a more specific node type (const overload).
auto as_array() -> array* final noexcept: Returns nullptr.
auto as_array() const -> const array* final noexcept: Returns nullptr.
auto as_boolean() -> toml::value<bool>* final noexcept: Returns nullptr.
auto as_boolean() const -> const toml::value<bool>* final noexcept: Returns nullptr.
auto as_date() -> toml::value<date>* final noexcept: Returns nullptr.
auto as_date() const -> const toml::value<date>* final noexcept: Returns nullptr.
auto as_date_time() -> toml::value<date_time>* final noexcept: Returns nullptr.
auto as_date_time() const -> const toml::value<date_time>* final noexcept: Returns nullptr.
auto as_floating_point() -> toml::value<double>* final noexcept: Returns nullptr.
auto as_floating_point() const -> const toml::value<double>* final noexcept: Returns nullptr.
auto as_integer() -> toml::value<int64_t>* final noexcept: Returns nullptr.
auto as_integer() const -> const toml::value<int64_t>* final noexcept: Returns nullptr.
auto as_string() -> toml::value<std::string>* final noexcept: Returns nullptr.
auto as_string() const -> const toml::value<std::string>* final noexcept: Returns nullptr.
auto as_table() -> table* final noexcept: Returns a pointer to the table.
auto as_table() const -> const table* final noexcept: Returns a const-qualified pointer to the table.
auto as_time() -> toml::value<time>* final noexcept: Returns nullptr.
auto as_time() const -> const toml::value<time>* final noexcept: Returns nullptr.

Type checks

template <typename T> auto is() const -> bool noexcept: Checks if a node is a specific type.
auto is_array() const -> bool final noexcept: Returns false.
auto is_array_of_tables() const -> bool final noexcept: Returns false.
auto is_boolean() const -> bool final noexcept: Returns false.
auto is_date() const -> bool final noexcept: Returns false.
auto is_date_time() const -> bool final noexcept: Returns false.
auto is_floating_point() const -> bool final noexcept: Returns false.
auto is_homogeneous(node_type ntype) const -> bool final noexcept: Checks if the node contains values/elements of only one type.
auto is_homogeneous(node_type ntype, node*& first_nonmatch) -> bool final noexcept: Checks if a node contains values/elements of only one type.
auto is_homogeneous(node_type ntype, const node*& first_nonmatch) const -> bool final noexcept: Checks if a node contains values/elements of only one type (const overload).
template <typename ElemType = void> auto is_homogeneous() const -> bool noexcept: Checks if the node contains values/elements of only one type.
auto is_integer() const -> bool final noexcept: Returns false.
auto is_number() const -> bool final noexcept: Returns false.
auto is_string() const -> bool final noexcept: Returns false.
auto is_table() const -> bool final noexcept: Returns true.
auto is_time() const -> bool final noexcept: Returns false.
auto is_value() const -> bool final noexcept: Returns false.
auto type() const -> node_type final noexcept: Returns toml::node_type::table.

Value retrieval

auto at(std::string_view key) -> node&: Gets a reference to the element at a specific key, throwing std::out_of_range if none existed.
auto at(std::string_view key) const -> const node&: Gets a reference to the element at a specific key, throwing std::out_of_range if none existed.
auto at(std::wstring_view key) -> node&: Gets a reference to the element at a specific key, throwing std::out_of_range if none existed.
auto at(std::wstring_view key) const -> const node&: Gets a reference to the element at a specific key, throwing std::out_of_range if none existed.
auto get(std::string_view key) -> node* noexcept: Gets the node at a specific key.
auto get(std::string_view key) const -> const node* noexcept: Gets the node at a specific key (const overload).
auto get(std::wstring_view key) -> node*: Gets the node at a specific key.
auto get(std::wstring_view key) const -> const node*: Gets the node at a specific key (const overload).
template <typename T> auto get_as(std::string_view key) -> impl::wrap_node<T>* noexcept: Gets the node at a specific key if it is a particular type.
template <typename T> auto get_as(std::string_view key) const -> const impl::wrap_node<T>* noexcept: Gets the node at a specific key if it is a particular type (const overload).
template <typename T> auto get_as(std::wstring_view key) -> impl::wrap_node<T>*: Gets the node at a specific key if it is a particular type.
template <typename T> auto get_as(std::wstring_view key) const -> const impl::wrap_node<T>*: Gets the node at a specific key if it is a particular type (const overload).
template <typename T> auto ref() & -> decltype(auto) noexcept: Gets a raw reference to a node's underlying data.
template <typename T> auto ref() && -> decltype(auto) noexcept: Gets a raw reference to a node's underlying data (rvalue overload).
template <typename T> auto ref() const & -> decltype(auto) noexcept: Gets a raw reference to a node's underlying data (const lvalue overload).
template <typename T> auto ref() const && -> decltype(auto) noexcept: Gets a raw reference to a node's underlying data (const rvalue overload).
template <typename T> auto value() const -> optional<T> noexcept(…): Gets the value contained by this node.
template <typename T> auto value_exact() const -> optional<T> noexcept(…): Gets the value contained by this node.
template <typename T> auto value_or(T&& default_value) const -> auto noexcept(…): Gets the raw value contained by this node, or a default.

Visitation

template <typename Func> auto visit(Func&& visitor) & -> decltype(auto) noexcept(…): Invokes a visitor on the node based on the node's concrete type.
template <typename Func> auto visit(Func&& visitor) && -> decltype(auto) noexcept(…): Invokes a visitor on the node based on the node's concrete type (rvalue overload).
template <typename Func> auto visit(Func&& visitor) const & -> decltype(auto) noexcept(…): Invokes a visitor on the node based on the node's concrete type (const lvalue overload).
template <typename Func> auto visit(Func&& visitor) const && -> decltype(auto) noexcept(…): Invokes a visitor on the node based on the node's concrete type (const rvalue overload).

Friends

auto operator<<(std::ostream& lhs, const table& rhs) -> std::ostream&: Prints the table out to a stream as formatted TOML.

Function documentation

toml::table::table(std::initializer_list<impl::table_init_pair> kvps) explicit

Constructs a table with one or more initial key-value pairs.

Parameters
kvps	A list of key-value pairs used to initialize the table.

auto tbl = toml::table{
    { "foo", 1 },
    { "bar", 2.0 },
    { "kek", "three" }
};
std::cout << tbl << "\n";

{ foo = 1, bar = 2.0, kek = "three" }

bool toml::table::operator!=(const table& lhs, const table& rhs) noexcept

Inequality operator.

Parameters
lhs	The LHS table.
rhs	The RHS table.
Returns	True if the tables did not contain the same keys and map.

bool toml::table::operator==(const table& lhs, const table& rhs) noexcept

Equality operator.

Parameters
lhs	The LHS table.
rhs	The RHS table.
Returns	True if the tables contained the same keys and map.

iterator toml::table::erase(iterator pos) noexcept

Removes the specified key-value pair from the table.

Parameters
pos	Iterator to the key-value pair being erased.
Returns	Iterator to the first key-value pair immediately following the removed key-value pair.

auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 }
};
std::cout << tbl << "\n";

tbl.erase(tbl.begin() + 1);
std::cout << tbl << "\n";

{ a = 1, b = 2, c = 3 }
{ a = 1, c = 3 }

iterator toml::table::erase(const_iterator pos) noexcept

Removes the specified key-value pair from the table (const iterator overload).

Parameters
pos	Iterator to the key-value pair being erased.
Returns	Iterator to the first key-value pair immediately following the removed key-value pair.

auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 }
};
std::cout << tbl << "\n";

tbl.erase(tbl.cbegin() + 1);
std::cout << tbl << "\n";

{ a = 1, b = 2, c = 3 }
{ a = 1, c = 3 }

iterator toml::table::erase(const_iterator begin, const_iterator end) noexcept

Removes the key-value pairs in the range [first, last) from the table.

Parameters
begin	Iterator to the first key-value pair being erased.
end	Iterator to the one-past-the-last key-value pair being erased.
Returns	Iterator to the first key-value pair immediately following the last removed key-value pair.

auto tbl = toml::table{
    { "a", 1 },
    { "b", "bad" },
    { "c", "karma" },
    { "d", 2 }
};
std::cout << tbl << "\n";

tbl.erase(tbl.cbegin() + 1, tbl.cbegin() + 3);
std::cout << tbl << "\n";

{ a = 1, b = "bad", c = "karma", d = 2 }
{ a = 1, d = 2 }

size_t toml::table::erase(std::string_view key) noexcept

Removes the value with the given key from the table.

Parameters
key	Key to erase.
Returns	Number of elements removed (0 or 1).

auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 }
};
std::cout << tbl << "\n";

std::cout << tbl.erase("b") << "\n";
std::cout << tbl.erase("not an existing key") << "\n";
std::cout << tbl << "\n";

{ a = 1, b = 2, c = 3 }
true
false
{ a = 1, c = 3 }

size_t toml::table::erase(std::wstring_view key)

Removes the value with the given key from the table.

Parameters
key	Key to erase.
Returns	Number of elements removed (0 or 1).

table& toml::table::prune(bool recursive = true) & noexcept

Removes empty child arrays and tables.

Parameters
recursive	Should child arrays and tables themselves be pruned?
Returns	A reference to the table.

auto tbl = toml::table{ { "a", 1 }, { "b", toml::array{ } }, { "c", toml::array{ toml::table{}, toml::array{} } } };
std::cout << arr << "\n";

arr.prune();
std::cout << arr << "\n";

{ a = 1, b = [], c = [ {}, [] ] }
{ a = 1 }

table&& toml::table::prune(bool recursive = true) && noexcept

Removes empty child arrays and tables (rvalue overload).

Parameters
recursive	Should child arrays and tables themselves be pruned?
Returns	An rvalue reference to the table.

template <typename ValueType = void, typename KeyType, typename... ValueArgs>
std::pair<iterator, bool> toml::table::emplace(KeyType&& key, ValueArgs && ... args)

Emplaces a new value at a specific key if one did not already exist.

Template parameters
ValueType	toml::table, toml::array, or any native TOML value type.
KeyType	A toml::key or any compatible string type.
ValueArgs	Value constructor argument types.
Parameters
key	The key at which to emplace the new value.
args	Arguments to forward to the value's constructor.
Returns	A std::pair containing: An iterator to the emplacement position (or the position of the value that prevented emplacement) A boolean indicating if the emplacement was successful.

auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 }
};
std::cout << tbl << "\n";

for (auto k : { "a", "d" })
{
    // add a string using std::string's substring constructor
    auto result = tbl.emplace<std::string>(k, "this is not a drill"sv, 14, 5);
    std::cout << "emplaced with key '"sv << k << "': "sv << result.second << "\n";
}
std::cout << tbl << "\n";

{ a = 1, b = 2, c = 3 }
emplaced with key 'a': false
emplaced with key 'd': true
{ a = 1, b = 2, c = 3, d = "drill" }

template <typename ValueType = void, typename KeyType, typename... ValueArgs>
iterator toml::table::emplace_hint(const_iterator hint, KeyType&& key, ValueArgs && ... args)

Emplaces a new value at a specific key if one did not already exist.

Template parameters
ValueType	toml::table, toml::array, or any native TOML value type.
KeyType	A toml::key or any compatible string type.
ValueArgs	Value constructor argument types.
Parameters
hint	Iterator to the position before which the new element will be emplaced.
key	The key at which to emplace the new value.
args	Arguments to forward to the value's constructor.
Returns	An iterator to the emplacement position (or the position of the value that prevented emplacement)

template <typename KeyType, typename ValueType>
std::pair<iterator, bool> toml::table::insert(KeyType&& key, ValueType&& val, value_flags flags = preserve_source_value_flags)

Inserts a new value at a specific key if one did not already exist.

Template parameters
KeyType	A toml::key or any compatible string type.
ValueType	toml::node, toml::node_view, toml::table, toml::array, or a native TOML value type (or a type promotable to one).
Parameters
key	The key at which to insert the new value.
val	The new value to insert.
flags	Value flags to apply to new values.
Returns	*Valid input:* An iterator to the insertion position (or the position of the value that prevented insertion) A boolean indicating if the insertion was successful. *Input is a null toml::node_view:* `{ end(), false }`

Try this code on Compiler Explorer
auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 }
};
std::cout << tbl << "\n";

for (auto k : { "a", "d" })
{
    auto result = tbl.insert(k, 42);
    std::cout << "inserted with key '"sv << k << "': "sv << result.second << "\n";
}
std::cout << tbl << "\n";

a = 1
b = 2
c = 3

inserted with key 'a': false
inserted with key 'd': true
a = 1
b = 2
c = 3
d = 42

template <typename Iter>
void toml::table::insert(Iter begin, Iter end, value_flags flags = preserve_source_value_flags)

Inserts a series of key-value pairs into the table.

Template parameters
Iter	An InputIterator to a collection of key-value pairs.
Parameters
begin	An iterator to the first value in the input collection.
end	An iterator to one-past-the-last value in the input collection.
flags	Value flags to apply to new values.

Try this code on Compiler Explorer
auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 }
};
std::cout << tbl << "\n";

auto kvps = std::array<std::pair<std::string, int>, 2>{{
    { "d", 42 },
    { "a", 43 } // won't be inserted, 'a' already exists
}};
tbl.insert(kvps.begin(), kvps.end());
std::cout << tbl << "\n";

a = 1
b = 2
c = 3

a = 1
b = 2
c = 3
d = 42

template <typename KeyType, typename ValueType>
std::pair<iterator, bool> toml::table::insert_or_assign(KeyType&& key, ValueType&& val, value_flags flags = preserve_source_value_flags)

Inserts or assigns a value at a specific key.

Template parameters
KeyType	A toml::key or any compatible string type.
ValueType	toml::node, toml::node_view, toml::table, toml::array, or a native TOML value type (or a type promotable to one).
Parameters
key	The key at which to insert or assign the value.
val	The value to insert/assign.
flags	Value flags to apply to new values.
Returns	*Valid input:* An iterator to the value's position `true` if the value was inserted, `false` if it was assigned. *Input is a null toml::node_view:* `{ end(), false }`

Try this code on Compiler Explorer
auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 }
};
std::cout << tbl << "\n";

for (auto k : { "a", "d" })
{
    auto result = tbl.insert_or_assign(k, 42);
    std::cout << "value at key '"sv << k
        << "' was "sv << (result.second ? "inserted"sv : "assigned"sv) << "\n";
}
std::cout << tbl << "\n";

a = 1
b = 2
c = 3

value at key 'a' was assigned
value at key 'd' was inserted
a = 42
b = 2
c = 3
d = 42

template <typename Func>
table& toml::table::for_each(Func&& visitor) & noexcept(…)

Invokes a visitor on each key-value pair in the table.

Template parameters
Func	A callable type invocable with one of the following signatures: `func(key, val)` `func(val)` Where: `key` will recieve a const reference to a toml::key `val` will recieve the value as it's concrete type with cvref-qualifications matching the table Visitors returning `bool` (or something convertible to `bool`) will cause iteration to stop if they return `false`.
Parameters
visitor	The visitor object.
Returns	A reference to the table.

toml::table tbl{
    { "0",  0      },
    { "1",  1      },
    { "2",  2      },
    { "3",  3.0    },
    { "4",  "four" },
    { "5",  "five" },
    { "6",  6      }
};

// select only the integers using a strongly-typed visitor
tbl.for_each([](toml::value<int64_t>& val)
{
    std::cout << val << ", ";
});
std::cout << "\n";

// select all the numeric values using a generic visitor + is_number<> metafunction
tbl.for_each([](auto&& val)
{
    if constexpr (toml::is_number<decltype(val)>)
        std::cout << val << ", ";
});
std::cout << "\n";

// select all the numeric values until we encounter something non-numeric
tbl.for_each([](auto&& val)
{
    if constexpr (toml::is_number<decltype(val)>)
    {
        std::cout << val << ", ";
        return true; // "keep going"
    }
    else
        return false; // "stop!"

});
std::cout << "\n\n";

// visitors may also recieve the key
tbl.for_each([](const toml::key& key, auto&& val)
{
    std::cout << key << ": " << val << "\n";
});

0, 1, 2, 6,
0, 1, 2, 3.0, 6,
0, 1, 2, 3.0,

0: 0
1: 1
2: 2
3: 3.0
4: 'four'
5: 'five'
6: 6

bool toml::table::is_inline() const noexcept

Returns true if this table is an inline table.

void toml::table::is_inline(bool val) noexcept

Sets whether this table is a TOML inline table.

Parameters
val	The new value for 'inline'.

Try this code on Compiler Explorer
auto tbl = toml::table{
    { "a", 1 },
    { "b", 2 },
    { "c", 3 },
    { "d", toml::table{ { "e", 4 } } }
};
std::cout << "is inline? "sv << tbl.is_inline() << "\n";
std::cout << tbl << "\n\n";

tbl.is_inline(!tbl.is_inline());
std::cout << "is inline? "sv << tbl.is_inline() << "\n";
std::cout << tbl << "\n";

is inline? false
a = 1
b = 2
c = 3

[d]
e = 4


is inline? true
{ a = 1, b = 2, c = 3, d = { e = 4 } }

node_view<node> toml::table::operator[](std::string_view key) noexcept

Gets a node_view for the selected value.

Parameters
key	The key used for the lookup.
Returns	A view of the value at the given key if one existed, or an empty node view.

node_view<const node> toml::table::operator[](std::string_view key) const noexcept

Gets a node_view for the selected value (const overload).

Parameters
key	The key used for the lookup.
Returns	A view of the value at the given key if one existed, or an empty node view.

node_view<node> toml::table::operator[](std::wstring_view key)

Gets a node_view for the selected value.

Parameters
key	The key used for the lookup.
Returns	A view of the value at the given key if one existed, or an empty node view.

node_view<const node> toml::table::operator[](std::wstring_view key) const

Gets a node_view for the selected value (const overload).

Parameters
key	The key used for the lookup.
Returns	A view of the value at the given key if one existed, or an empty node view.

bool toml::table::contains(std::wstring_view key) const

Returns true if the table contains a node at the given key.

iterator toml::table::find(std::string_view key) noexcept

Gets an iterator to the node at a specific key.

Parameters
key	The node's key.
Returns	An iterator to the node at the specified key, or end().

const_iterator toml::table::find(std::string_view key) const noexcept

Gets an iterator to the node at a specific key (const overload)

Parameters
key	The node's key.
Returns	A const iterator to the node at the specified key, or cend().

iterator toml::table::find(std::wstring_view key)

Gets an iterator to the node at a specific key.

Parameters
key	The node's key.
Returns	An iterator to the node at the specified key, or end().

const_iterator toml::table::find(std::wstring_view key) const

Gets an iterator to the node at a specific key (const overload).

Parameters
key	The node's key.
Returns	A const iterator to the node at the specified key, or cend().

iterator toml::table::lower_bound(std::string_view key) noexcept

Returns an iterator to the first key-value pair with key that is not less than the given key.

Returns	An iterator to the first matching key-value pair, or end().

const_iterator toml::table::lower_bound(std::string_view key) const noexcept

Returns a const iterator to the first key-value pair with key that is not less than the given key.

Returns	An iterator to the first matching key-value pair, or end().

iterator toml::table::lower_bound(std::wstring_view key)

Returns an iterator to the first key-value pair with key that is not less than the given key.

Returns	An iterator to the first matching key-value pair, or end().

const_iterator toml::table::lower_bound(std::wstring_view key) const

Returns a const iterator to the first key-value pair with key that is not less than the given key.

Returns	An iterator to the first matching key-value pair, or end().

bool toml::table::is_homogeneous(node_type ntype) const final noexcept

Checks if the node contains values/elements of only one type.

Parameters
ntype	A TOML node type. *toml::node_type::none:* "is every element the same type?" *Anything else:* "is every element one of these?"
Returns	True if the node was homogeneous.

auto arr = toml::array{ 1, 2, 3 };
std::cout << "homogenous: "sv << arr.is_homogeneous(toml::node_type::none) << "\n";
std::cout << "all floats: "sv << arr.is_homogeneous(toml::node_type::floating_point) << "\n";
std::cout << "all arrays: "sv << arr.is_homogeneous(toml::node_type::array) << "\n";
std::cout << "all ints:   "sv << arr.is_homogeneous(toml::node_type::integer) << "\n";

homogeneous: true
all floats:  false
all arrays:  false
all ints:    true

bool toml::table::is_homogeneous(node_type ntype, node*& first_nonmatch) final noexcept

Checks if a node contains values/elements of only one type.

Parameters
ntype	A TOML node type. *toml::node_type::none:* "is every element the same type?" *Anything else:* "is every element one of these?"
first_nonmatch	Reference to a pointer in which the address of the first non-matching element will be stored if the return value is false.
Returns	True if the node was homogeneous.

auto cfg = toml::parse("arr = [ 1, 2, 3, 4.0 ]");
toml::array& arr = *cfg["arr"].as_array();

toml::node* nonmatch{};
if (arr.is_homogeneous(toml::node_type::integer, nonmatch))
    std::cout << "array was homogeneous"sv << "\n";
else
    std::cout << "array was not homogeneous!\n"
    << "first non-match was a "sv << nonmatch->type() << " at " << nonmatch->source() << "\n";

array was not homogeneous!
first non-match was a floating-point at line 1, column 18

node& toml::table::at(std::wstring_view key)

Gets a reference to the element at a specific key, throwing std::out_of_range if none existed.

const node& toml::table::at(std::wstring_view key) const

Gets a reference to the element at a specific key, throwing std::out_of_range if none existed.

node* toml::table::get(std::string_view key) noexcept

Gets the node at a specific key.

Parameters
key	The node's key.
Returns	A pointer to the node at the specified key, or nullptr.

auto tbl = toml::table{
    { "a", 42, },
    { "b", "is the meaning of life, apparently." }
};
std::cout << R"(node ["a"] exists: )"sv << !!tbl.get("a") << "\n";
std::cout << R"(node ["b"] exists: )"sv << !!tbl.get("b") << "\n";
std::cout << R"(node ["c"] exists: )"sv << !!tbl.get("c") << "\n";
if (auto val = tbl.get("a"))
    std::cout << R"(node ["a"] was an )"sv << val->type() << "\n";

node ["a"] exists: true
node ["b"] exists: true
node ["c"] exists: false
node ["a"] was an integer

const node* toml::table::get(std::string_view key) const noexcept

Gets the node at a specific key (const overload).

Parameters
key	The node's key.
Returns	A pointer to the node at the specified key, or nullptr.

node* toml::table::get(std::wstring_view key)