general/tomlplusplus
2
0
Fork 0
mirror of https://github.com/marzer/tomlplusplus.git synced 2026-02-15 01:32:12 +00:00
Code Issues Projects Releases Wiki Activity

[skip ci] Updates

Browse Source
This commit is contained in:
ci-build
2020-02-13 18:47:47 +00:00
parent 2dbfc40d13
commit 68d06201f7
14 changed files with 1308 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
annotated.html
View File

@@ -58,10 +58,11 @@ C++17</a>
<a href="#" onclick="return toggle(this)">namespace</a> <a class="m-doc" href="namespacetoml.html">toml</a> <span class="m-doc">The root namespace for all toml++ functions and types.</span>
<ul class="m-doc">
<li>namespace <a class="m-doc" href="namespacetoml_1_1impl.html">impl</a> <span class="m-doc">Internal implementation details. No user-serviceable parts within.</span></li>
<li>namespace <a class="m-doc" href="namespacetoml_1_1literals.html">literals</a> <span class="m-label m-info m-flat tpp-injected tpp-inline-namespace" title="All members of this namespace are automatically members of the parent namespace. It does not require an explicit 'using' statement.">inline</span> <span class="m-doc">Literal operators used throughout toml++.</span></li>
<li>class <a class="m-doc" href="classtoml_1_1array.html">array</a> <span class="m-label m-flat m-warning">final</span> <span class="m-doc">A TOML array.</span></li>
<li>struct <a class="m-doc" href="structtoml_1_1date.html">date</a> <span class="m-label m-flat m-warning">final</span> <span class="m-doc">A local date.</span></li>
<li>struct <a class="m-doc" href="structtoml_1_1date__time.html">date_time</a> <span class="m-label m-flat m-warning">final</span> <span class="m-doc">A date-time.</span></li>
<li>class <a class="m-doc" href="classtoml_1_1default__formatter.html">default_formatter</a> <span class="m-label m-flat m-warning">final</span> <span class="m-doc">A wrapper for printing TOML objects out to a stream as formatted TOML.</span></li>
<li>class <a class="m-doc" href="classtoml_1_1json__formatter.html">json_formatter</a> <span class="m-label m-flat m-warning">final</span> <span class="m-doc">A wrapper for printing TOML objects out to a stream as formatted JSON.</span></li>
<li>class <a class="m-doc" href="classtoml_1_1node.html">node</a> <span class="m-doc">A TOML node.</span></li>
<li>class <a class="m-doc" href="classtoml_1_1parse__error.html">parse_error</a> <span class="m-label m-flat m-warning">final</span> <span class="m-doc">An error thrown/returned when parsing fails.</span></li>
<li>class <a class="m-doc" href="classtoml_1_1parse__result.html">parse_result</a> <span class="m-label m-flat m-warning">final</span> <span class="m-doc">The result of a parsing operation.</span></li>

307
classtoml_1_1array.html
View File

@@ -115,11 +115,11 @@ C++17</a>
<dt id="ada39844ba79a1f6fec4fbe7c8bc66eba">
using <a class="m-doc-self" href="#ada39844ba79a1f6fec4fbe7c8bc66eba">const_iterator</a> = impl::array_iterator&lt;true&gt;
</dt>
<dd>A const <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator" target="_blank">LegacyRandomAccessIterator</a> for iterating over the nodes in an array.</dd>
<dd>A const <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator" target="_blank">RandomAccessIterator</a> for iterating over the nodes in an array.</dd>
<dt id="a012d869144b5532229dd3ce1eac02bf6">
using <a class="m-doc-self" href="#a012d869144b5532229dd3ce1eac02bf6">iterator</a> = impl::array_iterator&lt;false&gt;
</dt>
<dd>A <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator" target="_blank">LegacyRandomAccessIterator</a> for iterating over the nodes in an array.</dd>
<dd>A <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator" target="_blank">RandomAccessIterator</a> for iterating over the nodes in an array.</dd>
</dl>
</section>
<section id="typeless-methods">
@@ -151,40 +151,40 @@ C++17</a>
<dt id="ac7652c1ab60af2ca1c7d52f0658639b4">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ac7652c1ab60af2ca1c7d52f0658639b4">back</a>(</span><span class="m-doc-wrap">) const -&gt; const <a class="m-doc" href="classtoml_1_1node.html">node</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a reference to the last element in the array.</dd>
<dd>Returns a reference to the last node in the array.</dd>
<dt id="a4c58dea5e8795e4b9f8df4f1e1473204">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a4c58dea5e8795e4b9f8df4f1e1473204">back</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1node.html">node</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a reference to the last element in the array.</dd>
<dd>Returns a reference to the last node in the array.</dd>
<dt id="a7cff1526a6d1f6157e0eab231b4757aa">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a7cff1526a6d1f6157e0eab231b4757aa">begin</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns an iterator to the first element.</dd>
<dd>Returns an iterator to the first node.</dd>
<dt id="a8ee8179ddf1cb44fdf0b8d0700f55c2f">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a8ee8179ddf1cb44fdf0b8d0700f55c2f">begin</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns an iterator to the first element.</dd>
<dd>Returns an iterator to the first node.</dd>
<dt id="a56d1cba006dccc5ad9982b58a8b2ddc1">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a56d1cba006dccc5ad9982b58a8b2ddc1">cbegin</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns an iterator to the first element.</dd>
<dd>Returns an iterator to the first node.</dd>
<dt id="a50e6b032805760f3930e02923d9a84b0">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a50e6b032805760f3930e02923d9a84b0">cend</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns an iterator to one-past-the-last element.</dd>
<dd>Returns an iterator to one-past-the-last node.</dd>
<dt id="adaa65bf63f29f898c27423306c165d68">
<span class="m-doc-wrap-bumper">void <a class="m-doc-self" href="#adaa65bf63f29f898c27423306c165d68">clear</a>(</span><span class="m-doc-wrap">) <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes all elements from the array.</dd>
<dd>Removes all nodes from the array.</dd>
<dt>
<div class="m-doc-template">template&lt;typename U, typename... V&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ab35d81ab4ccf9e8f98dc56fd25a98a8d">emplace</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
V &amp;&amp; ... args) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a></span>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a6467e68e1b35c27f876cf04be684a692">emplace</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
V &amp;&amp; ... args) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Emplaces a new value at a specific position in the array.</dd>
<dt>
<div class="m-doc-template">template&lt;typename U, typename... V&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#aa2561f1447787b4aab3719ed602d3ef6">emplace_back</a>(</span><span class="m-doc-wrap">V &amp;&amp; ... args) -&gt; decltype(auto)</span>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a3946fa8c822ddac062c43ca9a1a561eb">emplace_back</a>(</span><span class="m-doc-wrap">V &amp;&amp; ... args) -&gt; decltype(auto) <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Emplaces a new value at the end of the array.</dd>
<dt id="a5d527ea6bfddad1025e90e4363c822cc">
@@ -194,20 +194,20 @@ C++17</a>
<dt id="a778b5b807ff7329f7de10237d73f29c2">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a778b5b807ff7329f7de10237d73f29c2">end</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns an iterator to one-past-the-last element.</dd>
<dd>Returns an iterator to one-past-the-last node.</dd>
<dt id="adaf908b0cc3e8bcb1ee9ec9ec706d223">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#adaf908b0cc3e8bcb1ee9ec9ec706d223">end</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns an iterator to one-past-the-last element.</dd>
<dd>Returns an iterator to one-past-the-last node.</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a723388860d72c9a162137d0293366fb2">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> first,
<a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> last) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes the elements in the range [first, last) from the array.</dd>
<dd>Removes the nodes in the range [first, last) from the array.</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a22389a9ed9444fe52be10c4acbdec908">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes the specified element from the array.</dd>
<dd>Removes the specified node from the array.</dd>
<dt>
<span class="m-doc-wrap-bumper">void <a class="m-doc" href="#a86f7f312f44bcdca6fc35307e2843a4c">flatten</a>(</span><span class="m-doc-wrap">)</span>
</dt>
@@ -215,51 +215,51 @@ C++17</a>
<dt id="a5ba3af18c63546da6f9d2ac3b5b77f64">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a5ba3af18c63546da6f9d2ac3b5b77f64">front</a>(</span><span class="m-doc-wrap">) const -&gt; const <a class="m-doc" href="classtoml_1_1node.html">node</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a reference to the first element in the array.</dd>
<dd>Returns a reference to the first node in the array.</dd>
<dt id="a9c78848129a2a703c154e7cbe1a973d3">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a9c78848129a2a703c154e7cbe1a973d3">front</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1node.html">node</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a reference to the first element in the array.</dd>
<dd>Returns a reference to the first node in the array.</dd>
<dt>
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ac3f5a8093880f6a8ec4ed9f9bb5b23dc">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> index) const -&gt; const <a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets an element at a specific index if it is a particular type.</dd>
<dd>Gets the node at a specific index if it is a particular type (const overload).</dd>
<dt>
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a8bbe8bc0acab102ceb786b6b1fcb3fbe">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> index) -&gt; <a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets an element at a specific index if it is a particular type.</dd>
<dd>Gets the node at a specific index if it is a particular type.</dd>
<dt>
<div class="m-doc-template">template&lt;typename ITER&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a076fa11721262e4d39064f60a509571a">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a996b62fd852d39388a838b89f3458940">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
ITER first,
ITER last) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a></span>
ITER last) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Inserts a range of values into the array at a specific position.</dd>
<dt>
<div class="m-doc-template">template&lt;typename U&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a92f32393f2d868ad898b779bae8a6f33">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#aae228e38c14c8d6247a1ab4e4ddc151d">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> count,
U&amp;&amp; val) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a></span>
U&amp;&amp; val) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Repeatedly inserts a value starting at a specific position in the array.</dd>
<dt>
<div class="m-doc-template">template&lt;typename U&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a8137274d9eb1c77b88c6ae8bdfd4affd">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_list</a>&lt;U&gt; ilist) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a></span>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a2209e45b30df84c9f6da381cd0f92c07">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_list</a>&lt;U&gt; ilist) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Inserts a range of values into the array at a specific position.</dd>
<dt>
<div class="m-doc-template">template&lt;typename U&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ad444f1342e8c85330529daeca61d4628">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
U&amp;&amp; val) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a></span>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a106930bbdf1221941813f51aba1cc17e">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
U&amp;&amp; val) -&gt; <a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Inserts a new value at a specific position in the array.</dd>
<dd>Inserts a new node at a specific position in the array.</dd>
<dt id="a17362a39f6ec6f14ce59f8a8ed2b88cf">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a17362a39f6ec6f14ce59f8a8ed2b88cf">is_array</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is an array.</dd>
<dd>Always returns <code>true</code> for array nodes.</dd>
<dt id="ab8e15c4067237ab3192ab8f412bee0f6">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ab8e15c4067237ab3192ab8f412bee0f6">is_array_of_tables</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
@@ -268,15 +268,15 @@ C++17</a>
<div class="m-doc-template">template&lt;typename T = void&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a35ffeee7c5ba7a45dda85699af2b0f07">is_homogeneous</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Checks if the array contains values of only one type.</dd>
<dd>Checks if the array contains nodes of only one type.</dd>
<dt id="a30764b48a4c5cb191b620b77df4c8b00">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a30764b48a4c5cb191b620b77df4c8b00">is_table</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a table.</dd>
<dd>Always returns <code>false</code> for array nodes.</dd>
<dt id="a7a38831cec7e7215a6101ba40fc1ce11">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a7a38831cec7e7215a6101ba40fc1ce11">is_value</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a value.</dd>
<dd>Always returns <code>false</code> for array nodes.</dd>
<dt id="a7e5e45777e08941abb2069a5991e1f31">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a7e5e45777e08941abb2069a5991e1f31">operator=</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html">array</a>&amp;&amp; rhs) -&gt; <a class="m-doc" href="classtoml_1_1array.html">array</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
@@ -284,32 +284,32 @@ C++17</a>
<dt id="ae9f72a1b877f2ac66327a152d55aa9c6">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ae9f72a1b877f2ac66327a152d55aa9c6">operator[]</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> index) const -&gt; const <a class="m-doc" href="classtoml_1_1node.html">node</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a reference to the node element at a specific index.</dd>
<dd>Gets a reference to the node at a specific index.</dd>
<dt id="a853bad0297ca4dcee57c97da2fe318e7">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a853bad0297ca4dcee57c97da2fe318e7">operator[]</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> index) -&gt; <a class="m-doc" href="classtoml_1_1node.html">node</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a reference to the node element at a specific index.</dd>
<dd>Gets a reference to the node at a specific index.</dd>
<dt id="af99d72e29cef84f736d91d627b47a1dc">
<span class="m-doc-wrap-bumper">void <a class="m-doc-self" href="#af99d72e29cef84f736d91d627b47a1dc">pop_back</a>(</span><span class="m-doc-wrap">) <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes the last element from the array.</dd>
<dd>Removes the last node from the array.</dd>
<dt>
<div class="m-doc-template">template&lt;typename U&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a582ff45bc1e66ed9bcb848f3b1b0759d">push_back</a>(</span><span class="m-doc-wrap">U&amp;&amp; val) -&gt; decltype(auto)</span>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a1fe7d07a51adbd32c734bb99cbe3ff28">push_back</a>(</span><span class="m-doc-wrap">U&amp;&amp; val) -&gt; decltype(auto) <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Appends a new value to the end of the array.</dd>
<dt id="a1ba073adc52c3df5ad29cfd7e5daa1d5">
<span class="m-doc-wrap-bumper">void <a class="m-doc-self" href="#a1ba073adc52c3df5ad29cfd7e5daa1d5">reserve</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> new_capacity)</span>
</dt>
<dd>Reserves internal storage capacity up to a pre-determined number of elements.</dd>
<dd>Reserves internal storage capacity up to a pre-determined number of nodes.</dd>
<dt id="af81d7b6a1257ad766a47d9276855a7c9">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#af81d7b6a1257ad766a47d9276855a7c9">size</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns the number of elements in the array.</dd>
<dd>Returns the number of nodes in the array.</dd>
<dt id="a10f914637ff56f5bc6f96b089fd141a3">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a10f914637ff56f5bc6f96b089fd141a3">type</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="namespacetoml.html#abac3e84bbf1f2c90717fca107055f48d">node_<wbr/>type</a> <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns the node's type identifier.</dd>
<dd>Always returns <code><a class="m-doc" href="namespacetoml.html#abac3e84bbf1f2c90717fca107055f48daf1f713c9e000f5d3f280adbd124df4f5">node_type::<wbr/>array</a></code> for array nodes.</dd>
</dl>
</section>
<section id="friends">
@@ -358,27 +358,32 @@ C++17</a>
<tbody>
<tr>
<td>val</td>
<td>The value used to initialize element 0.</td>
<td>The value used to initialize node 0.</td>
</tr>
<tr>
<td>vals</td>
<td>The values used to initialize elements 1...N.</td>
<td>The values used to initialize nodes 1...N.</td>
</tr>
</tbody>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">1</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">,</span> <span class="s">"three"</span><span class="n">sv</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span> <span class="p">}</span> <span class="p">};</span>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mf">2.0</span><span class="p">,</span>
<span class="s">"three"</span><span class="n">sv</span><span class="p">,</span>
<span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span> <span class="p">}</span>
<span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [1, 2.0, "three", [4, 5]]</span></pre>
</div></section>
<section class="m-doc-details" id="ab35d81ab4ccf9e8f98dc56fd25a98a8d"><div>
<section class="m-doc-details" id="a6467e68e1b35c27f876cf04be684a692"><div>
<h3>
<div class="m-doc-template">
template&lt;typename U, typename... V&gt;
</div>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ab35d81ab4ccf9e8f98dc56fd25a98a8d">emplace</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
V &amp;&amp; ... args)</span></span>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a6467e68e1b35c27f876cf04be684a692">emplace</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
V &amp;&amp; ... args) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Emplaces a new value at a specific position in the array.</p>
<table class="m-table m-fullwidth m-flat">
@@ -415,13 +420,24 @@ C++17</a>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mi">2</span>
<span class="p">};</span>
<span class="c1">//add a string using std::string's substring constructor</span>
<span class="n">arr</span><span class="p">.</span><span class="n">emplace</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&gt;</span><span class="p">(</span><span class="n">arr</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="s">"this is not a drill"</span><span class="n">sv</span><span class="p">,</span> <span class="mi">14</span><span class="p">,</span> <span class="mi">5</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [1, "drill" 2]</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>There is no difference between insert and emplace For trivial value types (floats, ints, bools).</p></aside>
</div></section>
<section class="m-doc-details" id="aa2561f1447787b4aab3719ed602d3ef6"><div>
<section class="m-doc-details" id="a3946fa8c822ddac062c43ca9a1a561eb"><div>
<h3>
<div class="m-doc-template">
template&lt;typename U, typename... V&gt;
</div>
<span class="m-doc-wrap-bumper">decltype(auto) toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#aa2561f1447787b4aab3719ed602d3ef6">emplace_back</a>(</span><span class="m-doc-wrap">V &amp;&amp; ... args)</span></span>
<span class="m-doc-wrap-bumper">decltype(auto) toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a3946fa8c822ddac062c43ca9a1a561eb">emplace_back</a>(</span><span class="m-doc-wrap">V &amp;&amp; ... args) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Emplaces a new value at the end of the array.</p>
<table class="m-table m-fullwidth m-flat">
@@ -454,42 +470,110 @@ C++17</a>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mi">2</span>
<span class="p">};</span>
<span class="n">arr</span><span class="p">.</span><span class="n">emplace_back</span><span class="o">&lt;</span><span class="n">array</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="s">"four"</span><span class="n">sv</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [1, 2, [3, "four"]]</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>There is no difference between push_back and emplace_back For trivial value types (floats, ints, bools).</p></aside>
</div></section>
<section class="m-doc-details" id="a723388860d72c9a162137d0293366fb2"><div>
<h3>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a723388860d72c9a162137d0293366fb2">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> first,
<a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> last) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Removes the elements in the range [first, last) from the array.</p>
<p>Removes the nodes in the range [first, last) from the array.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">first</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first node being erased.</td>
</tr>
<tr>
<td>last</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the one-past-the-last node being erased.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th style="width: 1%">Returns</th>
<td>Iterator to the first element immediately following the last removed element.</td>
<th>Returns</th>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first node immediately following the last removed node.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="s">"bad"</span><span class="p">,</span>
<span class="s">"karma"</span>
<span class="mi">2</span><span class="p">,</span>
<span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">arr</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">arr</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="n">arr</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">3</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [1, "bad", "karma", 3]</span>
<span class="c1">// [1, 3]</span></pre>
</div></section>
<section class="m-doc-details" id="a22389a9ed9444fe52be10c4acbdec908"><div>
<h3>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a22389a9ed9444fe52be10c4acbdec908">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Removes the specified element from the array.</p>
<p>Removes the specified node from the array.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">pos</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the node being erased.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th style="width: 1%">Returns</th>
<td>Iterator to the first element immediately following the removed element.</td>
<th>Returns</th>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first node immediately following the removed node.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mi">2</span><span class="p">,</span>
<span class="mi">3</span>
<span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">arr</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">arr</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [1, 2, 3]</span>
<span class="c1">// [1, 3]</span></pre>
</div></section>
<section class="m-doc-details" id="a86f7f312f44bcdca6fc35307e2843a4c"><div>
<h3>
<span class="m-doc-wrap-bumper">void toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a86f7f312f44bcdca6fc35307e2843a4c">flatten</a>(</span><span class="m-doc-wrap">)</span></span>
</h3>
<p>Flattens this array, recursively hoisting the contents of child arrays up into itself.</p>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">5</span> <span class="p">}</span> <span class="p">},</span> <span class="mi">6</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{}</span> <span class="p">}</span>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mi">2</span><span class="p">,</span>
<span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">3</span><span class="p">,</span>
<span class="mi">4</span><span class="p">,</span>
<span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">5</span> <span class="p">}</span>
<span class="p">},</span>
<span class="mi">6</span><span class="p">,</span>
<span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{}</span>
<span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">arr</span><span class="p">.</span><span class="n">flatten</span><span class="p">();</span>
@@ -506,7 +590,7 @@ C++17</a>
</div>
<span class="m-doc-wrap-bumper">const <a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ac3f5a8093880f6a8ec4ed9f9bb5b23dc">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> index) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets an element at a specific index if it is a particular type.</p>
<p>Gets the node at a specific index if it is a particular type (const overload).</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
@@ -523,13 +607,13 @@ C++17</a>
<tbody>
<tr>
<td>index</td>
<td>The element index.</td>
<td>The node's index.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A pointer to the selected element if it was of the specified type, or nullptr.</td>
<td>A pointer to the selected node if it was of the specified type, or nullptr.</td>
</tr>
</tfoot>
</table>
@@ -541,7 +625,7 @@ C++17</a>
</div>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a8bbe8bc0acab102ceb786b6b1fcb3fbe">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> index) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets an element at a specific index if it is a particular type.</p>
<p>Gets the node at a specific index if it is a particular type.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
@@ -558,25 +642,34 @@ C++17</a>
<tbody>
<tr>
<td>index</td>
<td>The element index.</td>
<td>The node's index.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A pointer to the selected element if it was of the specified type, or nullptr.</td>
<td>A pointer to the selected node if it was of the specified type, or nullptr.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">42</span><span class="p">,</span>
<span class="s">"is the meaning of life, apparently."</span><span class="n">sv</span>
<span class="p">};</span>
<span class="k">if</span> <span class="p">(</span><span class="k">auto</span> <span class="n">val</span> <span class="o">=</span> <span class="n">arr</span><span class="p">.</span><span class="n">get_as</span><span class="o">&lt;</span><span class="kt">int64_t</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">0</span><span class="p">))</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"node [0] was an integer with value "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="o">**</span><span class="n">val</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// node [0] was an integer with value 42</span></pre>
</div></section>
<section class="m-doc-details" id="a076fa11721262e4d39064f60a509571a"><div>
<section class="m-doc-details" id="a996b62fd852d39388a838b89f3458940"><div>
<h3>
<div class="m-doc-template">
template&lt;typename ITER&gt;
</div>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a076fa11721262e4d39064f60a509571a">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a996b62fd852d39388a838b89f3458940">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
ITER first,
ITER last)</span></span>
ITER last) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Inserts a range of values into the array at a specific position.</p>
<table class="m-table m-fullwidth m-flat">
@@ -586,7 +679,7 @@ C++17</a>
<tbody>
<tr>
<td style="width: 1%">ITER</td>
<td>An iterator type. Must satisfy <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/ForwardIterator" target="_blank">LegacyForwardIterator</a>.</td>
<td>An iterator type. Must satisfy <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/ForwardIterator" target="_blank">ForwardIterator</a>.</td>
</tr>
</tbody>
<thead>
@@ -599,11 +692,11 @@ C++17</a>
</tr>
<tr>
<td>first</td>
<td>Iterator to the first value being inserted.</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first value being inserted.</td>
</tr>
<tr>
<td>last</td>
<td>Iterator to the one-past-the-last value being inserted.</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the one-past-the-last value being inserted.</td>
</tr>
</tbody>
<tfoot>
@@ -614,14 +707,14 @@ C++17</a>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="a92f32393f2d868ad898b779bae8a6f33"><div>
<section class="m-doc-details" id="aae228e38c14c8d6247a1ab4e4ddc151d"><div>
<h3>
<div class="m-doc-template">
template&lt;typename U&gt;
</div>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a92f32393f2d868ad898b779bae8a6f33">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#aae228e38c14c8d6247a1ab4e4ddc151d">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> count,
U&amp;&amp; val)</span></span>
U&amp;&amp; val) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Repeatedly inserts a value starting at a specific position in the array.</p>
<table class="m-table m-fullwidth m-flat">
@@ -658,14 +751,29 @@ C++17</a>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="s">"with an evil twinkle in its eye the goose said"</span><span class="p">,</span>
<span class="s">"and immediately we knew peace was never an option."</span>
<span class="p">};</span>
<span class="n">arr</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="n">arr</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="s">"honk"</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [</span>
<span class="c1">// "with an evil twinkle in its eye the goose said",</span>
<span class="c1">// "honk",</span>
<span class="c1">// "honk",</span>
<span class="c1">// "honk",</span>
<span class="c1">// "and immediately we knew peace was never an option."</span>
<span class="c1">// ]</span></pre>
</div></section>
<section class="m-doc-details" id="a8137274d9eb1c77b88c6ae8bdfd4affd"><div>
<section class="m-doc-details" id="a2209e45b30df84c9f6da381cd0f92c07"><div>
<h3>
<div class="m-doc-template">
template&lt;typename U&gt;
</div>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a8137274d9eb1c77b88c6ae8bdfd4affd">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_list</a>&lt;U&gt; ilist)</span></span>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a2209e45b30df84c9f6da381cd0f92c07">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a>pos,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_list</a>&lt;U&gt; ilist) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Inserts a range of values into the array at a specific position.</p>
<table class="m-table m-fullwidth m-flat">
@@ -699,15 +807,15 @@ C++17</a>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="ad444f1342e8c85330529daeca61d4628"><div>
<section class="m-doc-details" id="a106930bbdf1221941813f51aba1cc17e"><div>
<h3>
<div class="m-doc-template">
template&lt;typename U&gt;
</div>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ad444f1342e8c85330529daeca61d4628">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
U&amp;&amp; val)</span></span>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1array.html#a012d869144b5532229dd3ce1eac02bf6">iterator</a> toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a106930bbdf1221941813f51aba1cc17e">insert</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1array.html#ada39844ba79a1f6fec4fbe7c8bc66eba">const_<wbr/>iterator</a> pos,
U&amp;&amp; val) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Inserts a new value at a specific position in the array.</p>
<p>Inserts a new node at a specific position in the array.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
@@ -738,6 +846,16 @@ C++17</a>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mi">3</span>
<span class="p">};</span>
<span class="n">arr</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="n">arr</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="s">"two"</span><span class="p">);</span>
<span class="n">arr</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="n">arr</span><span class="p">.</span><span class="n">cend</span><span class="p">(),</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span> <span class="p">});</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [1, "two", 3, [4, 5]]</span></pre>
</div></section>
<section class="m-doc-details" id="a35ffeee7c5ba7a45dda85699af2b0f07"><div>
<h3>
@@ -746,7 +864,7 @@ C++17</a>
</div>
<span class="m-doc-wrap-bumper">bool toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a35ffeee7c5ba7a45dda85699af2b0f07">is_homogeneous</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Checks if the array contains values of only one type.</p>
<p>Checks if the array contains nodes of only one type.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
@@ -754,7 +872,7 @@ C++17</a>
<tbody>
<tr>
<td style="width: 1%">T</td>
<td><p>A TOML node type.</p><ul><li>Provide an explicit type for "is every element a T?"</li><li>Leave it as <code>void</code> for "is every element the same type?"</li></ul></td>
<td><p>A TOML node type.</p><ul><li>Provide an explicit type for "is every node a T?"</li><li>Leave it as <code>void</code> for "is every node the same type?"</li></ul></td>
</tr>
</tbody>
<tfoot>
@@ -764,14 +882,28 @@ C++17</a>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Remark</h4><p>Empty arrays are not regarded as homogeneous.</p></aside>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mi">2</span><span class="p">,</span>
<span class="mi">3</span>
<span class="p">};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"homogenous: "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span><span class="p">.</span><span class="n">is_homogeneous</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"all doubles: "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span><span class="p">.</span><span class="n">is_homogeneous</span><span class="o">&lt;</span><span class="kt">double</span><span class="o">&gt;</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"all arrays: "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span><span class="p">.</span><span class="n">is_homogeneous</span><span class="o">&lt;</span><span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="o">&gt;</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"all integers: "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span><span class="p">.</span><span class="n">is_homogeneous</span><span class="o">&lt;</span><span class="kt">int64_t</span><span class="o">&gt;</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// homogeneous: true</span>
<span class="c1">// all doubles: false</span>
<span class="c1">// all arrays: false</span>
<span class="c1">// all integers: true</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>Always returns <code>false</code> for empty arrays.</p></aside>
</div></section>
<section class="m-doc-details" id="a582ff45bc1e66ed9bcb848f3b1b0759d"><div>
<section class="m-doc-details" id="a1fe7d07a51adbd32c734bb99cbe3ff28"><div>
<h3>
<div class="m-doc-template">
template&lt;typename U&gt;
</div>
<span class="m-doc-wrap-bumper">decltype(auto) toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a582ff45bc1e66ed9bcb848f3b1b0759d">push_back</a>(</span><span class="m-doc-wrap">U&amp;&amp; val)</span></span>
<span class="m-doc-wrap-bumper">decltype(auto) toml::<wbr/>array::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a1fe7d07a51adbd32c734bb99cbe3ff28">push_back</a>(</span><span class="m-doc-wrap">U&amp;&amp; val) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Appends a new value to the end of the array.</p>
<table class="m-table m-fullwidth m-flat">
@@ -800,6 +932,17 @@ C++17</a>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">arr</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span>
<span class="mi">1</span><span class="p">,</span>
<span class="mi">2</span>
<span class="p">};</span>
<span class="n">arr</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="mi">3</span><span class="p">);</span>
<span class="n">arr</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="mf">4.0</span><span class="p">);</span>
<span class="n">arr</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">array</span><span class="p">{</span> <span class="mi">5</span><span class="p">,</span> <span class="s">"six"</span><span class="n">sv</span> <span class="p">});</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">arr</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// [1, 2, 3, 4.0, [5, "six"]]</span></pre>
</div></section>
<section class="m-doc-details" id="af06c7437a0946a9d5e093d903b59f6a4"><div>
<h3>

58
namespacetoml_1_1literals.html → classtoml_1_1default__formatter.html
View File

@@ -1,7 +1,7 @@
<!DOCTYPE html>
<html lang="en"><head>
<meta charset="utf-8"/>
<title>toml::literals namespace | toml++ TOML
<title>toml::default_formatter class | toml++ TOML
Parser
for
C++17</title>
@@ -52,29 +52,39 @@ C++17</a>
<div class="m-row">
<div class="m-col-l-10 m-push-l-1">
<h1>
<span class="m-breadcrumb"><a href="namespacetoml.html">toml</a>::<wbr/></span>literals <span class="m-thin">namespace</span>
<span class="m-label m-info tpp-injected tpp-inline-namespace" title="All members of this namespace are automatically members of the parent namespace. It does not require an explicit 'using' statement.">inline</span></h1>
<p>Literal operators used throughout toml++.</p>
<div class="m-block m-default">
<h3>Contents</h3>
<ul>
<li>
Reference
<ul>
<li><a href="#func-members">Functions</a></li>
</ul>
</li>
</ul>
</div>
<section id="func-members">
<h2><a href="#func-members">Functions</a></h2>
<dl class="m-doc">
<dt id="a4a1fced946c998e169e75fddecf18363">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a4a1fced946c998e169e75fddecf18363">operator""_sz</a>(</span><span class="m-doc-wrap">unsigned long long n) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Creates a <code><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a></code> literal.</dd>
</dl>
</section>
<div class="m-doc-template">template&lt;typename CHAR = char&gt;</div>
<span class="m-breadcrumb"><a href="namespacetoml.html">toml</a>::<wbr/></span>default_formatter <span class="m-thin">class</span> <span class="m-label m-flat m-warning">final</span>
</h1>
<p>A wrapper for printing TOML objects out to a stream as formatted TOML.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">CHAR</td>
<td>The underlying character type of the output stream. Must be 1 byte in size.</td>
</tr>
</tbody>
</table>
<aside class="m-note m-default"><h4>Remark</h4><p>You generally don't need to create an instance of this class explicitly; the stream operators of the TOML node types already print themselves out using this formatter.</p></aside><pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span>
<span class="p">{</span> <span class="s">"description"</span><span class="p">,</span> <span class="s">"This is some TOML, yo."</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"fruit"</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="s">"apple"</span><span class="p">,</span> <span class="s">"orange"</span><span class="p">,</span> <span class="s">"pear"</span> <span class="p">}</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"numbers"</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">array</span><span class="p">{</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span> <span class="p">}</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"table"</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span> <span class="p">{</span> <span class="s">"foo"</span><span class="p">,</span> <span class="s">"bar"</span> <span class="p">}</span> <span class="p">}}</span> <span class="p">}</span>
<span class="p">}};</span>
<span class="c1">// these two lines are equivalent:</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">toml</span><span class="o">::</span><span class="n">default_formatter</span><span class="p">{</span> <span class="n">tbl</span> <span class="p">}</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output (twice):</span>
<span class="c1">// description = "This is some TOML, yo."</span>
<span class="c1">// fruit = ["apple", "orange", "pear"]</span>
<span class="c1">// numbers = [1, 2, 3, 4, 5]</span>
<span class="c1">// </span>
<span class="c1">// [table]</span>
<span class="c1">// foo = "bar"</span></pre>
</div>
</div>
</div>

222
classtoml_1_1json__formatter.html Normal file
View File

@@ -0,0 +1,222 @@
<!DOCTYPE html>
<html lang="en"><head>
<meta charset="utf-8"/>
<title>toml::json_formatter class | toml++ TOML
Parser
for
C++17</title>
<link href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,400i,600,600i%7CSource+Code+Pro:400,400i,600" rel="stylesheet"/>
<link href="m-dark+documentation.compiled.css" rel="stylesheet"/>
<link href="tomlplusplus.css" rel="stylesheet"/>
<link href="favicon-dark.png" rel="icon" type="image/png"/>
<meta content="width=device-width, initial-scale=1.0" name="viewport"/>
<meta content="#22272e" name="theme-color"/>
<script src="tomlplusplus.js"></script>
</head>
<body>
<header><nav id="navigation">
<div class="m-container">
<div class="m-row">
<span class="m-col-t-8 m-col-m-none m-left-m" id="m-navbar-brand">
<a href="https://github.com/marzer/tomlplusplus/">toml++</a> <span class="m-breadcrumb">|</span> <a class="m-thin" href="namespacetoml.html">TOML
Parser
for
C++17</a>
</span>
<div class="m-col-t-4 m-hide-m m-text-right m-nopadr">
<a class="m-doc-search-icon" href="#search" onclick="return showSearch()" title="Search"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
<path d="m6 0c-3.31 0-6 2.69-6 6 0 3.31 2.69 6 6 6 1.49 0 2.85-0.541 3.89-1.44-0.0164 0.338 0.147 0.759 0.5 1.15l3.22 3.79c0.552 0.614 1.45 0.665 2 0.115 0.55-0.55 0.499-1.45-0.115-2l-3.79-3.22c-0.392-0.353-0.812-0.515-1.15-0.5 0.895-1.05 1.44-2.41 1.44-3.89 0-3.31-2.69-6-6-6zm0 1.56a4.44 4.44 0 0 1 4.44 4.44 4.44 4.44 0 0 1-4.44 4.44 4.44 4.44 0 0 1-4.44-4.44 4.44 4.44 0 0 1 4.44-4.44z" id="m-doc-search-icon-path"></path>
</svg></a>
<a href="#navigation" id="m-navbar-show" title="Show navigation"></a>
<a href="#" id="m-navbar-hide" title="Hide navigation"></a>
</div>
<div class="m-col-t-12 m-show-m m-col-m-none m-right-m" id="m-navbar-collapse">
<div class="m-row">
<ol class="m-col-t-6 m-col-m-none">
<li><a href="namespaces.html">Namespaces</a></li>
</ol>
<ol class="m-col-t-6 m-col-m-none" start="2">
<li><a href="annotated.html">Classes</a></li>
<li><a href="https://github.com/marzer/tomlplusplus/" target="_blank">Github</a></li>
<li class="m-show-m"><a class="m-doc-search-icon" href="#search" onclick="return showSearch()" title="Search"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
<use href="#m-doc-search-icon-path"></use>
</svg></a></li>
</ol>
</div>
</div>
</div>
</div>
</nav></header>
<main><article>
<div class="m-container m-container-inflatable">
<div class="m-row">
<div class="m-col-l-10 m-push-l-1">
<h1>
<div class="m-doc-template">template&lt;typename CHAR = char&gt;</div>
<span class="m-breadcrumb"><a href="namespacetoml.html">toml</a>::<wbr/></span>json_formatter <span class="m-thin">class</span> <span class="m-label m-flat m-warning">final</span>
</h1>
<p>A wrapper for printing TOML objects out to a stream as formatted JSON.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">CHAR</td>
<td>The underlying character type of the output stream. Must be 1 byte in size.</td>
</tr>
</tbody>
</table>
<div class="m-block m-default">
<h3>Contents</h3>
<ul>
<li>
Reference
<ul>
<li><a href="#typeless-methods">Constructors, destructors, conversion operators</a></li>
<li><a href="#friends">Friends</a></li>
</ul>
</li>
</ul>
</div>
<pre class="m-code"><span class="k">auto</span> <span class="n">some_toml</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">parse</span><span class="p">(</span><span class="sa">R</span><span class="s">"</span><span class="dl">(</span><span class="s"></span>
<span class="s"> [fruit]</span>
<span class="s"> apple.color = "red"</span>
<span class="s"> apple.taste.sweet = true</span>
<span class="s"> [fruit.apple.texture]</span>
<span class="s"> smooth = true</span>
<span class="dl">)</span><span class="s">"</span><span class="n">sv</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">toml</span><span class="o">::</span><span class="n">json_formatter</span><span class="p">{</span> <span class="n">some_toml</span> <span class="p">}</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// {</span>
<span class="c1">// "fruit" : {</span>
<span class="c1">// "apple" : {</span>
<span class="c1">// "color" : "red",</span>
<span class="c1">// "taste" : {</span>
<span class="c1">// "sweet" : true</span>
<span class="c1">// },</span>
<span class="c1">// "texture" : {</span>
<span class="c1">// "smooth" : true</span>
<span class="c1">// }</span>
<span class="c1">// }</span>
<span class="c1">// }</span>
<span class="c1">// }</span></pre>
<section id="typeless-methods">
<h2><a href="#typeless-methods">Constructors, destructors, conversion operators</a></h2>
<dl class="m-doc">
<dt>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="#a372da7254f9c9bd6193cb833240dfa85">json_formatter</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="classtoml_1_1node.html">toml::<wbr/>node</a>&amp; source,
format_flags flags = format_flags::quote_dates_and_times) <span class="m-label m-flat m-info">explicit</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Constructs a JSON formatter and binds it to a TOML object.</dd>
</dl>
</section>
<section id="friends">
<h2><a href="#friends">Friends</a></h2>
<dl class="m-doc">
<dt id="ad7eefe5d1660391d7209b9de4f588dba">
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ad7eefe5d1660391d7209b9de4f588dba">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;T&gt;&amp; lhs,
<a class="m-doc" href="classtoml_1_1json__formatter.html">json_<wbr/>formatter</a>&amp;&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp;</span>
</dt>
<dd>Prints the bound TOML object out to the stream as JSON (rvalue overload).</dd>
<dt id="a0171ac6e6e3826b7d5739ce827483be2">
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a0171ac6e6e3826b7d5739ce827483be2">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;T&gt;&amp; lhs,
<a class="m-doc" href="classtoml_1_1json__formatter.html">json_<wbr/>formatter</a>&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;T&gt;&amp;</span>
</dt>
<dd>Prints the bound TOML object out to the stream as JSON.</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-doc-details" id="a372da7254f9c9bd6193cb833240dfa85"><div>
<h3>
<div class="m-doc-template">
template&lt;typename CHAR&gt;
</div>
<span class="m-doc-wrap-bumper"> toml::<wbr/>json_formatter&lt;CHAR&gt;::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a372da7254f9c9bd6193cb833240dfa85">json_formatter</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="classtoml_1_1node.html">toml::<wbr/>node</a>&amp; source,
format_flags flags = format_flags::quote_dates_and_times) <span class="m-label m-info">explicit</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Constructs a JSON formatter and binds it to a TOML object.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">source</td>
<td>The source TOML object.</td>
</tr>
<tr>
<td>flags</td>
<td>Format option flags.</td>
</tr>
</tbody>
</table>
</div></section>
</section>
</div>
</div>
</div>
</article></main>
<div class="m-doc-search" id="search">
<a href="#!" onclick="return hideSearch()"></a>
<div class="m-container">
<div class="m-row">
<div class="m-col-m-8 m-push-m-2">
<div class="m-doc-search-header m-text m-small">
<div><span class="m-label m-default">Tab</span> / <span class="m-label m-default">T</span> to search, <span class="m-label m-default">Esc</span> to close</div>
<div id="search-symbolcount">…</div>
</div>
<div class="m-doc-search-content">
<form>
<input autocomplete="off" autofocus="autofocus" disabled="disabled" id="search-input" name="q" placeholder="Loading …" spellcheck="false" type="search"/>
</form>
<noscript class="m-text m-danger m-text-center">Unlike everything else in the docs, the search functionality <em>requires</em> JavaScript.</noscript>
<div class="m-text m-dim m-text-center" id="search-help">
<p class="m-noindent">Search for symbols, directories, files, pages or
modules. You can omit any prefix from the symbol or file path; adding a
<code>:</code> or <code>/</code> suffix lists all members of given symbol or
directory.</p>
<p class="m-noindent">Use <span class="m-label m-dim">↓</span>
/ <span class="m-label m-dim">↑</span> to navigate through the list,
<span class="m-label m-dim">Enter</span> to go.
<span class="m-label m-dim">Tab</span> autocompletes common prefix, you can
copy a link to the result using <span class="m-label m-dim">⌘</span>
<span class="m-label m-dim">L</span> while <span class="m-label m-dim">⌘</span>
<span class="m-label m-dim">M</span> produces a Markdown link.</p>
</div>
<div class="m-text m-warning m-text-center" id="search-notfound">Sorry, nothing was found.</div>
<ul id="search-results"></ul>
</div>
</div>
</div>
</div>
</div>
<script src="search-v1.js"></script>
<script async="async" src="searchdata-v1.js"></script>
<footer><nav>
<div class="m-container">
<div class="m-row">
<div class="m-col-l-10 m-push-l-1">
<a href="https://github.com/marzer/tomlplusplus/" target="_blank">Github</a>
•
<a href="https://github.com/marzer/tomlplusplus/issues" target="_blank">Report
an
issue</a>
<br/><br/>Documentation
generated
using
<a href="https://mcss.mosra.cz/">m.css</a>
</div>
</div>
</div>
</nav></footer>
</body></html>

366
classtoml_1_1table.html
View File

@@ -70,7 +70,7 @@ C++17</a>
</li>
</ul>
</div>
<aside class="m-note m-default"><h4>Remark</h4><p>The interface of this type is modeled after <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/container/map" target="_blank">std::map</a>, with some additional considerations made for the heterogeneous nature of a TOML table.</p></aside><pre class="m-code"><span class="c1">// example</span>
<aside class="m-note m-default"><h4>Remark</h4><p>The interface of this type is modeled after <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/container/map" target="_blank">std::map</a>, with some additional considerations made for the heterogeneous nature of a TOML table, and for the removal of some cruft (the public interface of <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/container/map" target="_blank">std::map</a> is, simply, <em>a hot mess</em>).</p></aside><pre class="m-code"><span class="c1">// example</span>
<span class="c1">// code</span>
<span class="c1">// here</span></pre>
<section id="base-classes">
@@ -88,11 +88,11 @@ C++17</a>
<dt id="a5f20440eb54f783f1704574b1e612a39">
using <a class="m-doc-self" href="#a5f20440eb54f783f1704574b1e612a39">const_iterator</a> = impl::table_iterator&lt;true&gt;
</dt>
<dd>A const <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator" target="_blank">LegacyBidirectionalIterator</a> for iterating over the key-value pairs in a table.</dd>
<dd>A const <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator" target="_blank">BidirectionalIterator</a> for iterating over the key-value pairs in a table.</dd>
<dt id="aef09012c31a3d28ba1960da887872dbf">
using <a class="m-doc-self" href="#aef09012c31a3d28ba1960da887872dbf">iterator</a> = impl::table_iterator&lt;false&gt;
</dt>
<dd>A <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator" target="_blank">LegacyBidirectionalIterator</a> for iterating over the key-value pairs in a table.</dd>
<dd>A <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator" target="_blank">BidirectionalIterator</a> for iterating over the key-value pairs in a table.</dd>
</dl>
</section>
<section id="typeless-methods">
@@ -140,6 +140,10 @@ C++17</a>
<span class="m-doc-wrap-bumper">void <a class="m-doc-self" href="#aa710f85c588a1b00c3192d1553de4eef">clear</a>(</span><span class="m-doc-wrap">) <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes all key-value pairs from the table.</dd>
<dt id="ace2b078b9e963016488ba738dde73e7f">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ace2b078b9e963016488ba738dde73e7f">contains</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) const -&gt; bool <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if the table contains a node at the given key.</dd>
<dt id="a554f495f6f2ebc993be1bd0379447051">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a554f495f6f2ebc993be1bd0379447051">empty</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
@@ -152,22 +156,65 @@ C++17</a>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a96da67654c5ca131cfec2e3c07aa2730">end</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns an iterator to one-past-the-last key-value pair.</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a020e8f71bec1fbff52260a5a1e0cb12e">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1table.html#a5f20440eb54f783f1704574b1e612a39">const_<wbr/>iterator</a> first,
<a class="m-doc" href="classtoml_1_1table.html#a5f20440eb54f783f1704574b1e612a39">const_<wbr/>iterator</a> last) -&gt; <a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes the key-value pairs in the range [first, last) from the table.</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a4dafb4ae116d92add973e5f27f880a9d">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1table.html#a5f20440eb54f783f1704574b1e612a39">const_<wbr/>iterator</a> pos) -&gt; <a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes the specified key-value pair from the table (const iterator overload).</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a1a90984876ccdd03aaa9e0f9801a839f">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> pos) -&gt; <a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes the specified key-value pair from the table.</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ad91ed36ee1b3cec423d49d36f3ed366e">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) -&gt; bool <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Removes the value with the given key from the table.</dd>
<dt>
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#af95e571827dda4724fe83ccb33ff584d">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) const -&gt; const <a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets the node at a specific key if it is a particular type (const overload).</dd>
<dt>
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ad1c10909feeb58f5b03ee78deffe7f46">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) -&gt; <a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets the node at a specific key if it is a particular type.</dd>
<dt id="a8d24e995e5cfab4933c82ccd95dd6fa3">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a8d24e995e5cfab4933c82ccd95dd6fa3">is_array</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is an array.</dd>
<dd>Always returns <code>false</code> for table nodes.</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a53be1b93aa90608ed378323df835a2f3">is_inline</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this table is an inline table.</dd>
<dt>
<span class="m-doc-wrap-bumper">void <a class="m-doc" href="#a8e797a683ff2bacd14d7e7461ecd2780">is_inline</a>(</span><span class="m-doc-wrap">bool val) <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Sets whether this table is a TOML inline table.</dd>
<dt id="ad2f9333f6aeb634f4ddbec38493da7c2">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ad2f9333f6aeb634f4ddbec38493da7c2">is_table</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a table.</dd>
<dd>Always returns <code>true</code> for table nodes.</dd>
<dt id="af137c1e4cf632015709d6a566cc74edc">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#af137c1e4cf632015709d6a566cc74edc">is_value</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a value.</dd>
<dd>Always returns <code>false</code> for table nodes.</dd>
<dt id="a5c5fd0e11db828ab264eccc96dfdd619">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a5c5fd0e11db828ab264eccc96dfdd619">operator=</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1table.html">table</a>&amp;&amp; rhs) -&gt; <a class="m-doc" href="classtoml_1_1table.html">table</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Move-assignment operator.</dd>
<dt id="a7d7aa640d81cc7efd308fbf8c56263ce">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a7d7aa640d81cc7efd308fbf8c56263ce">operator[]</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) const -&gt; node_view&lt;const <a class="m-doc" href="classtoml_1_1table.html">table</a>&gt; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a node_view for the selected key-value pair (const overload).</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ac0ee38b7d9cbc7ca736f699c90acd833">operator[]</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) -&gt; node_view&lt;<a class="m-doc" href="classtoml_1_1table.html">table</a>&gt; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a node_view for the selected key-value pair.</dd>
<dt id="ad7c4105854cc817bf6e781fa7fb1b6d6">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ad7c4105854cc817bf6e781fa7fb1b6d6">size</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
@@ -175,7 +222,7 @@ C++17</a>
<dt id="afe589750b98c702710d643a81ed6b9af">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#afe589750b98c702710d643a81ed6b9af">type</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="namespacetoml.html#abac3e84bbf1f2c90717fca107055f48d">node_<wbr/>type</a> <span class="m-label m-flat m-warning">override</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns the node's type identifier.</dd>
<dd>Always returns <code><a class="m-doc" href="namespacetoml.html#abac3e84bbf1f2c90717fca107055f48daaab9e1de16f38176f86d7a92ba337a8d">node_type::<wbr/>table</a></code> for table nodes.</dd>
</dl>
</section>
<section id="friends">
@@ -230,7 +277,310 @@ C++17</a>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// {{ "foo", 1 }, { "bar", 2.0 }, { "kek", "three" }}</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>C++ <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_lists</a> represent their member elements as const even if the list's value type is non-const. This is great for compiler writers, I guess, but pretty annoying for me since TOML key-value pairs are polymorphic. This means that for the human-friendly braced init list syntax to work I can't use <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_list</a> and must instead invent an annoying proxy type, which means an extra level of nesting.<br/><br/>See <a href="https://en.cppreference.com/w/cpp/utility/initializer_list">https://en.cppreference.com/w/cpp/utility/initializer_<wbr/>list</a> if you'd like to be more annoyed about this.</p></aside>
<span class="c1">// { foo = 1, bar = 2.0, kek = "three" }</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>C++ <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_lists</a> represent their member elements as const even if the list's value type is non-const. This is great for compiler writers, I guess, but pretty annoying for me since TOML key-value pairs are polymorphic. This means that for the human-friendly braced init list syntax to work I can't use <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/initializer_list" target="_blank">std::initializer_list</a> and must instead invent an annoying proxy type, which means an extra level of nesting.<br/><br/>See <a href="https://en.cppreference.com/w/cpp/utility/initializer_list">https://en.cppreference.com/w/cpp/utility/initializer_<wbr/>list</a> if you'd like to be more annoyed about this.</p></aside>
</div></section>
<section class="m-doc-details" id="a020e8f71bec1fbff52260a5a1e0cb12e"><div>
<h3>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a020e8f71bec1fbff52260a5a1e0cb12e">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1table.html#a5f20440eb54f783f1704574b1e612a39">const_<wbr/>iterator</a> first,
<a class="m-doc" href="classtoml_1_1table.html#a5f20440eb54f783f1704574b1e612a39">const_<wbr/>iterator</a> last) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Removes the key-value pairs in the range [first, last) from the table.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">first</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first key-value pair being erased.</td>
</tr>
<tr>
<td>last</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the one-past-the-last key-value pair being erased.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first key-value pair immediately following the last removed key-value pair.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span>
<span class="p">{</span> <span class="s">"a"</span><span class="p">,</span> <span class="mi">1</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"bad"</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"c"</span><span class="p">,</span> <span class="s">"karma"</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"d"</span><span class="p">,</span> <span class="mi">2</span> <span class="p">}</span>
<span class="p">}};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">tbl</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">tbl</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="n">tbl</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">3</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// { a = 1, b = "bad", c = "karma", d = 2 }</span>
<span class="c1">// { a = 1, d = 2 }</span></pre>
</div></section>
<section class="m-doc-details" id="a4dafb4ae116d92add973e5f27f880a9d"><div>
<h3>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a4dafb4ae116d92add973e5f27f880a9d">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1table.html#a5f20440eb54f783f1704574b1e612a39">const_<wbr/>iterator</a> pos) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Removes the specified key-value pair from the table (const iterator overload).</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">pos</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the key-value pair being erased.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first key-value pair immediately following the removed key-value pair.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span>
<span class="p">{</span> <span class="s">"a"</span><span class="p">,</span> <span class="mi">1</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"b"</span><span class="p">,</span> <span class="mi">2</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"c"</span><span class="p">,</span> <span class="mi">3</span> <span class="p">}</span>
<span class="p">}};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">tbl</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">tbl</span><span class="p">.</span><span class="n">cbegin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// { a = 1, b = 2, c = 3 }</span>
<span class="c1">// { a = 1, c = 3 }</span></pre>
</div></section>
<section class="m-doc-details" id="a1a90984876ccdd03aaa9e0f9801a839f"><div>
<h3>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a1a90984876ccdd03aaa9e0f9801a839f">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="classtoml_1_1table.html#aef09012c31a3d28ba1960da887872dbf">iterator</a> pos) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Removes the specified key-value pair from the table.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">pos</td>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the key-value pair being erased.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/named_req/Iterator" target="_blank">Iterator</a> to the first key-value pair immediately following the removed key-value pair.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span>
<span class="p">{</span> <span class="s">"a"</span><span class="p">,</span> <span class="mi">1</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"b"</span><span class="p">,</span> <span class="mi">2</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"c"</span><span class="p">,</span> <span class="mi">3</span> <span class="p">}</span>
<span class="p">}};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">tbl</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">tbl</span><span class="p">.</span><span class="n">begin</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// { a = 1, b = 2, c = 3 }</span>
<span class="c1">// { a = 1, c = 3 }</span></pre>
</div></section>
<section class="m-doc-details" id="ad91ed36ee1b3cec423d49d36f3ed366e"><div>
<h3>
<span class="m-doc-wrap-bumper">bool toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ad91ed36ee1b3cec423d49d36f3ed366e">erase</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Removes the value with the given key from the table.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">key</td>
<td>Key to erase.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if any values with matching keys were found and erased.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span>
<span class="p">{</span> <span class="s">"a"</span><span class="p">,</span> <span class="mi">1</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"b"</span><span class="p">,</span> <span class="mi">2</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"c"</span><span class="p">,</span> <span class="mi">3</span> <span class="p">}</span>
<span class="p">}};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="s">"b"</span><span class="p">)</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="s">"not an existing key"</span><span class="p">)</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// { a = 1, b = 2, c = 3 }</span>
<span class="c1">// true</span>
<span class="c1">// false</span>
<span class="c1">// { a = 1, c = 3 }</span></pre>
</div></section>
<section class="m-doc-details" id="af95e571827dda4724fe83ccb33ff584d"><div>
<h3>
<div class="m-doc-template">
template&lt;typename T&gt;
</div>
<span class="m-doc-wrap-bumper">const <a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#af95e571827dda4724fe83ccb33ff584d">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets the node at a specific key if it is a particular type (const overload).</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">T</td>
<td>The node's type.</td>
</tr>
</tbody>
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td>key</td>
<td>The node's key.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A pointer to the selected node if it was of the specified type, or nullptr.</td>
</tr>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="ad1c10909feeb58f5b03ee78deffe7f46"><div>
<h3>
<div class="m-doc-template">
template&lt;typename T&gt;
</div>
<span class="m-doc-wrap-bumper"><a class="m-doc" href="namespacetoml.html#a7c937f95568df080c3584862c25f4030">node_<wbr/>of</a>&lt;T&gt;* toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ad1c10909feeb58f5b03ee78deffe7f46">get_as</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets the node at a specific key if it is a particular type.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">T</td>
<td>The node's type.</td>
</tr>
</tbody>
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td>key</td>
<td>The node's key.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A pointer to the selected node if it was of the specified type, or nullptr.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span>
<span class="p">{</span> <span class="s">"a"</span><span class="p">,</span> <span class="mi">42</span><span class="p">,</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"is the meaning of life, apparently."</span> <span class="p">}</span>
<span class="p">}};</span>
<span class="k">if</span> <span class="p">(</span><span class="k">auto</span> <span class="n">val</span> <span class="o">=</span> <span class="n">arr</span><span class="p">.</span><span class="n">get_as</span><span class="o">&lt;</span><span class="kt">int64_t</span><span class="o">&gt;</span><span class="p">(</span><span class="s">"a"</span><span class="p">))</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">node</span> <span class="p">[</span><span class="err">\</span><span class="s">"a</span><span class="se">\"</span><span class="s">] was an integer with value "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="o">**</span><span class="n">val</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// node ["a"] was an integer with value 42</span></pre>
</div></section>
<section class="m-doc-details" id="a53be1b93aa90608ed378323df835a2f3"><div>
<h3>
<span class="m-doc-wrap-bumper">bool toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a53be1b93aa90608ed378323df835a2f3">is_inline</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Returns true if this table is an inline table.</p>
<aside class="m-note m-default"><h4>Remark</h4><p>Runtime-constructed tables (i.e. those not created during parsing) are not inline by default.</p></aside>
</div></section>
<section class="m-doc-details" id="a8e797a683ff2bacd14d7e7461ecd2780"><div>
<h3>
<span class="m-doc-wrap-bumper">void toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a8e797a683ff2bacd14d7e7461ecd2780">is_inline</a>(</span><span class="m-doc-wrap">bool val) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Sets whether this table is a TOML inline table.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">val</td>
<td>The new value for 'inline'.</td>
</tr>
</tbody>
</table>
<pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span>
<span class="p">{</span> <span class="s">"a"</span><span class="p">,</span> <span class="mi">1</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"b"</span><span class="p">,</span> <span class="mi">2</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"c"</span><span class="p">,</span> <span class="mi">3</span> <span class="p">},</span>
<span class="p">{</span> <span class="s">"d"</span><span class="p">,</span> <span class="n">toml</span><span class="o">::</span><span class="n">table</span><span class="p">{{</span> <span class="p">{</span> <span class="s">"e"</span><span class="p">,</span> <span class="mi">4</span> <span class="p">}</span> <span class="p">}}</span> <span class="p">}</span>
<span class="p">}};</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"is inline? "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span><span class="p">.</span><span class="n">is_inline</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">tbl</span><span class="p">.</span><span class="n">is_inline</span><span class="p">(</span><span class="o">!</span><span class="n">tbl</span><span class="p">.</span><span class="n">is_inline</span><span class="p">());</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"is inline? "</span><span class="n">sv</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span><span class="p">.</span><span class="n">is_inline</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">tbl</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// example output:</span>
<span class="c1">// is inline? false</span>
<span class="c1">// a = 1</span>
<span class="c1">// b = 2</span>
<span class="c1">// c = 3</span>
<span class="c1">// [d]</span>
<span class="c1">// e = 4</span>
<span class="c1">//</span>
<span class="c1">// is inline? true</span>
<span class="c1">// { a = 1, b = 2, c = 3, d = { e = 4 } }</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>A table being 'inline' is only relevent during printing; it has no effect on the general functionality of the table object.</p></aside>
</div></section>
<section class="m-doc-details" id="ac0ee38b7d9cbc7ca736f699c90acd833"><div>
<h3>
<span class="m-doc-wrap-bumper">node_view&lt;<a class="m-doc" href="classtoml_1_1table.html">table</a>&gt; toml::<wbr/>table::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ac0ee38b7d9cbc7ca736f699c90acd833">operator[]</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="namespacetoml.html#a496653fce75ee70bbe451bb5f2377265">string_<wbr/>view</a> key) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets a node_view for the selected key-value pair.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">key</td>
<td>The key used for the lookup.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A node_view.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Remark</h4><p><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/container/map" target="_blank">std::map</a>::operator[]'s behaviour of constructing an element at a key if it didn't exist is terribad, so I've deliberately chosen not to emulate that insane bug-factory. This Is Not An Error (tm).</p></aside><aside class="m-note m-default"><h4>See also</h4><p>toml::node_view</p></aside>
</div></section>
<section class="m-doc-details" id="abdeb5d9d9fc23c031c78e544c6196ea6"><div>
<h3>

1
namespaces.html
View File

@@ -58,7 +58,6 @@ C++17</a>
<a href="#" onclick="return toggle(this)">namespace</a> <a class="m-doc" href="namespacetoml.html">toml</a> <span class="m-doc">The root namespace for all toml++ functions and types.</span>
<ul class="m-doc">
<li>namespace <a class="m-doc" href="namespacetoml_1_1impl.html">impl</a> <span class="m-doc">Internal implementation details. No user-serviceable parts within.</span></li>
<li>namespace <a class="m-doc" href="namespacetoml_1_1literals.html">literals</a> <span class="m-label m-info m-flat tpp-injected tpp-inline-namespace" title="All members of this namespace are automatically members of the parent namespace. It does not require an explicit 'using' statement.">inline</span> <span class="m-doc">Literal operators used throughout toml++.</span></li>
</ul>
</li>
</ul>

31
namespacetoml.html
View File

@@ -76,8 +76,6 @@ C++17</a>
<dl class="m-doc">
<dt>namespace <a class="m-doc" href="namespacetoml_1_1impl.html">impl</a></dt>
<dd>Internal implementation details. No user-serviceable parts within.</dd>
<dt>namespace <a class="m-doc" href="namespacetoml_1_1literals.html">literals</a> <span class="m-label m-info m-flat tpp-injected tpp-inline-namespace" title="All members of this namespace are automatically members of the parent namespace. It does not require an explicit 'using' statement.">inline</span></dt>
<dd>Literal operators used throughout toml++.</dd>
</dl>
</section>
<section id="nested-classes">
@@ -95,6 +93,16 @@ C++17</a>
struct <a class="m-doc" href="structtoml_1_1date__time.html">date_time</a>
</dt>
<dd>A date-time.</dd>
<dt>
<div class="m-doc-template">template&lt;typename CHAR = char&gt;</div>
class <a class="m-doc" href="classtoml_1_1default__formatter.html">default_formatter</a>
</dt>
<dd>A wrapper for printing TOML objects out to a stream as formatted TOML.</dd>
<dt>
<div class="m-doc-template">template&lt;typename CHAR = char&gt;</div>
class <a class="m-doc" href="classtoml_1_1json__formatter.html">json_formatter</a>
</dt>
<dd>A wrapper for printing TOML objects out to a stream as formatted JSON.</dd>
<dt>
class <a class="m-doc" href="classtoml_1_1node.html">node</a>
</dt>
@@ -179,11 +187,6 @@ C++17</a>
using <a class="m-doc" href="#a496653fce75ee70bbe451bb5f2377265">string_view</a>= <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string_view" target="_blank">std::string_view</a>
</dt>
<dd>The string type for keys and string values.</dd>
<dt id="a7b72195a2db21f3eb407442ce9993d01">
<div class="m-doc-template">template&lt;typename T&gt;</div>
using <a class="m-doc-self" href="#a7b72195a2db21f3eb407442ce9993d01">value_of</a> = typename impl::node_unwrapper&lt;T&gt;::type
</dt>
<dd>Helper alias that unwraps TOML node type to it's raw value equivalent.</dd>
</dl>
</section>
<section id="func-members">
@@ -194,10 +197,6 @@ C++17</a>
const <a class="m-doc" href="classtoml_1_1table.html">table</a>&amp; rhs) -&gt; bool <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd></dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="namespacetoml_1_1literals.html#a4a1fced946c998e169e75fddecf18363">operator""_sz</a>(</span><span class="m-doc-wrap">unsigned long long n) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a> <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Creates a <code><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/size_t" target="_blank">size_t</a></code> literal.</dd>
<dt id="aaa1ee3cd7e3a50ae76f0da76eb21a0bc">
<div class="m-doc-template">template&lt;typename CHAR&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aaa1ee3cd7e3a50ae76f0da76eb21a0bc">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp; lhs,
@@ -363,28 +362,28 @@ C++17</a>
using toml::<wbr/><a class="m-doc-self" href="#ae845239fd7271e3d8e529302d300ad5b">source_index</a>= <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">uint16_t</a>
</h3>
<p>The integer type used to tally line numbers and columns.</p>
<aside class="m-note m-warning"><h4>Attention</h4><p>This will be <code><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">uint32_t</a></code> if <code>TOML_LARGE_FILES</code> is <code>1</code>.</p></aside>
<aside class="m-note m-default"><h4>Remark</h4><p>This will be an alias for <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">uint32_t</a> if <code>TOML_LARGE_FILES</code> is <code>1</code>.</p></aside>
</div></section>
<section class="m-doc-details" id="a1d0523987bb329ff90f8d14550b5f3a6"><div>
<h3>
using toml::<wbr/><a class="m-doc-self" href="#a1d0523987bb329ff90f8d14550b5f3a6">string</a>= <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::string</a>
</h3>
<p>The string type for keys and string values.</p>
<aside class="m-note m-warning"><h4>Attention</h4><p>This will be <code><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::u8string</a></code> if <code>TOML_CHAR_8_STRINGS</code> is <code>1</code>.</p></aside>
<aside class="m-note m-default"><h4>Remark</h4><p>This will be an alias for <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::u8string</a> if <code>TOML_CHAR_8_STRINGS</code> is <code>1</code>.</p></aside>
</div></section>
<section class="m-doc-details" id="a29d79a4734dc5c63b2b749b02fc0b823"><div>
<h3>
using toml::<wbr/><a class="m-doc-self" href="#a29d79a4734dc5c63b2b749b02fc0b823">string_char</a> = char
</h3>
<p>The base character type for keys and string values.</p>
<aside class="m-note m-warning"><h4>Attention</h4><p>This will be <code><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/language/types" target="_blank">char8_t</a></code> if <code>TOML_CHAR_8_STRINGS</code> is <code>1</code>.</p></aside>
<aside class="m-note m-default"><h4>Remark</h4><p>This will be an alias for <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/language/types" target="_blank">char8_t</a> if <code>TOML_CHAR_8_STRINGS</code> is <code>1</code>.</p></aside>
</div></section>
<section class="m-doc-details" id="a496653fce75ee70bbe451bb5f2377265"><div>
<h3>
using toml::<wbr/><a class="m-doc-self" href="#a496653fce75ee70bbe451bb5f2377265">string_view</a>= <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string_view" target="_blank">std::string_view</a>
</h3>
<p>The string type for keys and string values.</p>
<aside class="m-note m-warning"><h4>Attention</h4><p>This will be <code><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string_view" target="_blank">std::u8string_view</a></code> if <code>TOML_CHAR_8_STRINGS</code> is <code>1</code>.</p></aside>
<aside class="m-note m-default"><h4>Remark</h4><p>This will be an alias for <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string_view" target="_blank">std::u8string_view</a> if <code>TOML_CHAR_8_STRINGS</code> is <code>1</code>.</p></aside>
</div></section>
</section>
<section>
@@ -613,7 +612,7 @@ C++17</a>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Remark</h4><p>You must <code>#include <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/header/fstream" target="_blank">&lt;fstream&gt;</a></code> to use this function (<code>toml++</code> does not transitively include it for you).</p></aside>
<aside class="m-note m-default"><h4>Remark</h4><p>You must <code>#include <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/header/fstream" target="_blank">&lt;fstream&gt;</a></code> to use this function (toml++ does not transitively include it for you).</p></aside>
</div></section>
</section>
</div>

2
searchdata-v1.js
View File

File diff suppressed because one or more lines are too long

81
structtoml_1_1date.html
View File

@@ -62,6 +62,7 @@ C++17</a>
Reference
<ul>
<li><a href="#pub-attribs">Public variables</a></li>
<li><a href="#friends">Friends</a></li>
</ul>
</li>
</ul>
@@ -80,6 +81,86 @@ C++17</a>
<dd>The year component.</dd>
</dl>
</section>
<section id="friends">
<h2><a href="#friends">Friends</a></h2>
<dl class="m-doc">
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#af2ad5cc7af0b184e6fab182f32df8a1c">operator!=</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1date.html">date</a> lhs,
<a class="m-doc" href="structtoml_1_1date.html">date</a> rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Inequality operator.</dd>
<dt id="a10635f4b1bdc3b2e8b811e518fa0b80a">
<div class="m-doc-template">template&lt;typename CHAR&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a10635f4b1bdc3b2e8b811e518fa0b80a">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp; lhs,
const <a class="m-doc" href="structtoml_1_1date.html">date</a>&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp;</span>
</dt>
<dd>Prints a date out to a stream as <code>YYYY-MM-DD</code> (per RFC 3339).</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a07ff3f69b41d69e780aac60d11e8a2a8">operator==</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1date.html">date</a> lhs,
<a class="m-doc" href="structtoml_1_1date.html">date</a> rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Equality operator.</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-doc-details" id="af2ad5cc7af0b184e6fab182f32df8a1c"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#af2ad5cc7af0b184e6fab182f32df8a1c">operator!=</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1date.html">date</a> lhs,
<a class="m-doc" href="structtoml_1_1date.html">date</a> rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Inequality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS date.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS date.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the dates did not represent the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="a07ff3f69b41d69e780aac60d11e8a2a8"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a07ff3f69b41d69e780aac60d11e8a2a8">operator==</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1date.html">date</a> lhs,
<a class="m-doc" href="structtoml_1_1date.html">date</a> rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Equality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS date.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS date.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the dates represented the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
</section>
</div>
</div>
</div>

102
structtoml_1_1date__time.html
View File

@@ -61,11 +61,22 @@ C++17</a>
<li>
Reference
<ul>
<li><a href="#pub-methods">Public functions</a></li>
<li><a href="#pub-attribs">Public variables</a></li>
<li><a href="#friends">Friends</a></li>
</ul>
</li>
</ul>
</div>
<section id="pub-methods">
<h2><a href="#pub-methods">Public functions</a></h2>
<dl class="m-doc">
<dt id="af0d6119984645eb015f2fad0ef487bbc">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#af0d6119984645eb015f2fad0ef487bbc">is_local</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a> does not contain timezone offset information.</dd>
</dl>
</section>
<section id="pub-attribs">
<h2><a href="#pub-attribs">Public variables</a></h2>
<dl class="m-doc">
@@ -77,11 +88,100 @@ C++17</a>
<a class="m-doc" href="structtoml_1_1time.html">toml::<wbr/>time</a> <a class="m-doc-self" href="#a18d5e772db4f61635643cda390c2b720">time</a>
</dt>
<dd>The time component.</dd>
<dt id="abf91ad8c70f0c3fd54690923c348b972"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/optional" target="_blank">std::optional</a>&lt;<a class="m-doc" href="structtoml_1_1time__offset.html">toml::<wbr/>time_offset</a>&gt; <a class="m-doc-self" href="#abf91ad8c70f0c3fd54690923c348b972">time_offset</a>
<dt><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/optional" target="_blank">std::optional</a>&lt;<a class="m-doc" href="structtoml_1_1time__offset.html">toml::<wbr/>time_offset</a>&gt; <a class="m-doc" href="#abf91ad8c70f0c3fd54690923c348b972">time_offset</a>
</dt>
<dd>The timezone offset component.</dd>
</dl>
</section>
<section id="friends">
<h2><a href="#friends">Friends</a></h2>
<dl class="m-doc">
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a9ae0e032ffe90928c47b40bd8155dea3">operator!=</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Inequality operator.</dd>
<dt id="a83781edbe072ba7916c2793c0a15d4c2">
<div class="m-doc-template">template&lt;typename CHAR&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a83781edbe072ba7916c2793c0a15d4c2">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp; lhs,
const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp;</span>
</dt>
<dd>Prints a <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a> out to a stream in RFC 3339 format.</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a885cbe902aeadacb0953230ade9d8b9a">operator==</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Equality operator.</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-doc-details" id="a9ae0e032ffe90928c47b40bd8155dea3"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a9ae0e032ffe90928c47b40bd8155dea3">operator!=</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Inequality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the date_times did not represent the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="a885cbe902aeadacb0953230ade9d8b9a"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a885cbe902aeadacb0953230ade9d8b9a">operator==</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&amp; rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Equality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the date_times represented the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
</section>
<section>
<h2>Variable documentation</h2>
<section class="m-doc-details" id="abf91ad8c70f0c3fd54690923c348b972"><div>
<h3><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/utility/optional" target="_blank">std::optional</a>&lt;<a class="m-doc" href="structtoml_1_1time__offset.html">toml::<wbr/>time_offset</a>&gt; toml::<wbr/>date_time::<wbr/><a class="m-doc-self" href="#abf91ad8c70f0c3fd54690923c348b972">time_offset</a>
</h3>
<p>The timezone offset component.</p>
<aside class="m-note m-default"><h4>Remark</h4><p>The <a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a> is said to be 'local' if the <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> is empty.</p></aside>
</div></section>
</section>
</div>
</div>
</div>

39
structtoml_1_1source__position.html
View File

@@ -63,10 +63,18 @@ C++17</a>
<ul>
<li><a href="#typeless-methods">Constructors, destructors, conversion operators</a></li>
<li><a href="#pub-attribs">Public variables</a></li>
<li><a href="#friends">Friends</a></li>
</ul>
</li>
</ul>
</div>
<pre class="m-code"><span class="k">auto</span> <span class="n">table</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">parse_file</span><span class="p">(</span><span class="s">"config.toml"</span><span class="n">sv</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"The node 'description' was defined at "</span><span class="n">sv</span>
<span class="o">&lt;&lt;</span> <span class="n">table</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">"description"</span><span class="p">)</span><span class="o">-&gt;</span><span class="n">source</span><span class="p">().</span><span class="n">begin</span><span class="p">()</span>
<span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// possible output:</span>
<span class="c1">// The value 'description' was defined at line 7, column 15</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>toml++'s parser is unicode-aware insofar as it knows how to handle various non-conventional whitespace and newline characters, but it doesn't give much thought to combining marks, grapheme clusters vs. characters, et cetera. If a TOML document contains lots of codepoints outside of the ASCII range you may find that your source_positions don't match those given by a text editor (typically the line numbers will be accurate but column numbers will be too high).<br/><br/>This Is Not An Error (tm). I've chosen this behaviour as a deliberate trade-off between parser complexity and correctness.</p></aside>
<section id="typeless-methods">
<h2><a href="#typeless-methods">Constructors, destructors, conversion operators</a></h2>
<dl class="m-doc">
@@ -89,6 +97,37 @@ C++17</a>
<dd>The line number.</dd>
</dl>
</section>
<section id="friends">
<h2><a href="#friends">Friends</a></h2>
<dl class="m-doc">
<dt id="a90fec8fa1014a1358a362f9171cdb073">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a90fec8fa1014a1358a362f9171cdb073">operator!=</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if two source_positions do not represent the same line and column.</dd>
<dt id="a771714902fb113445597a1fd2a24e8cd">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a771714902fb113445597a1fd2a24e8cd">operator&lt;</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if the LHS position is before the RHS position.</dd>
<dt id="aa87323f3ce926e11feb7e30fde4b6ec5">
<div class="m-doc-template">template&lt;typename CHAR&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aa87323f3ce926e11feb7e30fde4b6ec5">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp; lhs,
const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp;</span>
</dt>
<dd>Prints a <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a> to a stream.</dd>
<dt id="abb7d47c85374301ec48e7c5f3ee1c71a">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#abb7d47c85374301ec48e7c5f3ee1c71a">operator&lt;=</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if the LHS position is before the RHS position or equal to it.</dd>
<dt id="a2661adb822c0291c5328d9d00e4b9a8f">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a2661adb822c0291c5328d9d00e4b9a8f">operator==</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1source__position.html">source_<wbr/>position</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if two source_positions represent the same line and column.</dd>
</dl>
</section>
<section>
<h2>Variable documentation</h2>
<section class="m-doc-details" id="a1ca6d0db40c69d2784703011f7cf5434"><div>

19
structtoml_1_1source__region.html
View File

@@ -62,10 +62,18 @@ C++17</a>
Reference
<ul>
<li><a href="#pub-attribs">Public variables</a></li>
<li><a href="#friends">Friends</a></li>
</ul>
</li>
</ul>
</div>
<pre class="m-code"><span class="k">auto</span> <span class="n">table</span> <span class="o">=</span> <span class="n">toml</span><span class="o">::</span><span class="n">parse_file</span><span class="p">(</span><span class="s">"config.toml"</span><span class="n">sv</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"The node 'server' was defined at "</span><span class="n">sv</span>
<span class="o">&lt;&lt;</span> <span class="n">table</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">"server"</span><span class="p">)</span><span class="o">-&gt;</span><span class="n">source</span><span class="p">()</span>
<span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// possible output:</span>
<span class="c1">// The node 'server' was defined at line 3, column 1 - line 10, column 25 of 'config.toml'</span></pre><aside class="m-note m-default"><h4>Remark</h4><p>toml++'s parser is unicode-aware insofar as it knows how to handle various non-conventional whitespace and newline characters, but it doesn't give much thought to combining marks, grapheme clusters vs. characters, et cetera. If a TOML document contains lots of codepoints outside of the ASCII range you may find that your source_positions don't match those given by a text editor (typically the line numbers will be accurate but column numbers will be too high).<br/><br/>This Is Not An Error (tm). I've chosen this behaviour as a deliberate trade-off between parser complexity and correctness.</p></aside>
<section id="pub-attribs">
<h2><a href="#pub-attribs">Public variables</a></h2>
<dl class="m-doc">
@@ -83,6 +91,17 @@ C++17</a>
<dd>The path to the corresponding source document.</dd>
</dl>
</section>
<section id="friends">
<h2><a href="#friends">Friends</a></h2>
<dl class="m-doc">
<dt id="ab0e918c50ed25c1645506229b5e700be">
<div class="m-doc-template">template&lt;typename CHAR&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ab0e918c50ed25c1645506229b5e700be">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp; lhs,
const <a class="m-doc" href="structtoml_1_1source__region.html">source_<wbr/>region</a>&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp;</span>
</dt>
<dd>Prints a <a class="m-doc" href="structtoml_1_1source__region.html">source_<wbr/>region</a> to a stream.</dd>
</dl>
</section>
<section>
<h2>Variable documentation</h2>
<section class="m-doc-details" id="a25fc23f579edb8afc0818c013c5ac5d7"><div>

81
structtoml_1_1time.html
View File

@@ -62,6 +62,7 @@ C++17</a>
Reference
<ul>
<li><a href="#pub-attribs">Public variables</a></li>
<li><a href="#friends">Friends</a></li>
</ul>
</li>
</ul>
@@ -83,6 +84,86 @@ C++17</a>
<dd>The second component, from 0 - 59.</dd>
</dl>
</section>
<section id="friends">
<h2><a href="#friends">Friends</a></h2>
<dl class="m-doc">
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a76766a077e105960758caa4a9cbfd25b">operator!=</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Inequality operator.</dd>
<dt id="a4e1b80dd301e0c285f01fbc14e61b624">
<div class="m-doc-template">template&lt;typename CHAR&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a4e1b80dd301e0c285f01fbc14e61b624">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp; lhs,
const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp;</span>
</dt>
<dd>Prints a time out to a stream as <code>HH:MM:SS.FFFFFF</code> (per RFC 3339).</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#aa88d156f8ea405513e00702b3c88de2f">operator==</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Equality operator.</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-doc-details" id="a76766a077e105960758caa4a9cbfd25b"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a76766a077e105960758caa4a9cbfd25b">operator!=</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Inequality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS time.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS time.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the times did not represent the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="aa88d156f8ea405513e00702b3c88de2f"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#aa88d156f8ea405513e00702b3c88de2f">operator==</a>(</span><span class="m-doc-wrap">const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; lhs,
const <a class="m-doc" href="structtoml_1_1time.html">time</a>&amp; rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Equality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS time.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS time.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the times represented the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
</section>
</div>
</div>
</div>

130
structtoml_1_1time__offset.html
View File

@@ -61,11 +61,23 @@ C++17</a>
<li>
Reference
<ul>
<li><a href="#pub-static-methods">Public static functions</a></li>
<li><a href="#pub-attribs">Public variables</a></li>
<li><a href="#friends">Friends</a></li>
</ul>
</li>
</ul>
</div>
<section id="pub-static-methods">
<h2><a href="#pub-static-methods">Public static functions</a></h2>
<dl class="m-doc">
<dt>
<span class="m-doc-wrap-bumper">static auto <a class="m-doc" href="#ad8cf5c07125c1751680d4263f23f3912">from_hh_mm</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int8_t</a> hours,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int8_t</a> minutes) -&gt; <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Creates a timezone offset from separate hour and minute totals.</dd>
</dl>
</section>
<section id="pub-attribs">
<h2><a href="#pub-attribs">Public variables</a></h2>
<dl class="m-doc">
@@ -74,6 +86,124 @@ C++17</a>
<dd>Offset from UTC+0, in minutes.</dd>
</dl>
</section>
<section id="friends">
<h2><a href="#friends">Friends</a></h2>
<dl class="m-doc">
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#a77e5bb056ffcd6a91b1740333f23b806">operator!=</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> lhs,
<a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Inequality operator.</dd>
<dt id="aeb1ff77a47b5fd3bbf7bfb7afaa42129">
<div class="m-doc-template">template&lt;typename CHAR&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aeb1ff77a47b5fd3bbf7bfb7afaa42129">operator&lt;&lt;</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp; lhs,
const <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a>&amp; rhs) -&gt; <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/io/basic_ostream" target="_blank">std::basic_ostream</a>&lt;CHAR&gt;&amp;</span>
</dt>
<dd>Prints a <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> out to a stream as <code>+-HH:MM or Z</code> (per RFC 3339).</dd>
<dt>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ad9423ee067d0a4c0ba39deb2679a07f6">operator==</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> lhs,
<a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> rhs) -&gt; friend bool <span class="m-label m-flat m-primary">constexpr</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Equality operator.</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-doc-details" id="ad8cf5c07125c1751680d4263f23f3912"><div>
<h3>
<span class="m-doc-wrap-bumper">static <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> toml::<wbr/>time_offset::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ad8cf5c07125c1751680d4263f23f3912">from_hh_mm</a>(</span><span class="m-doc-wrap"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int8_t</a> hours,
<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int8_t</a> minutes) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Creates a timezone offset from separate hour and minute totals.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">hours</td>
<td>The total hours.</td>
</tr>
<tr>
<td>minutes</td>
<td>The total minutes.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a>.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">time_offset</span><span class="o">::</span><span class="n">from_hh_mm</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">30</span><span class="p">)</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">time_offset</span><span class="o">::</span><span class="n">from_hh_mm</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">30</span><span class="p">)</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">time_offset</span><span class="o">::</span><span class="n">from_hh_mm</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">30</span><span class="p">)</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">time_offset</span><span class="o">::</span><span class="n">from_hh_mm</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">)</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// output: </span>
<span class="c1">// +02:30</span>
<span class="c1">// -01:30</span>
<span class="c1">// -02:30</span>
<span class="c1">// Z</span></pre>
</div></section>
<section class="m-doc-details" id="a77e5bb056ffcd6a91b1740333f23b806"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a77e5bb056ffcd6a91b1740333f23b806">operator!=</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> lhs,
<a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Inequality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a>.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a>.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the time_offsets did not represent the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="ad9423ee067d0a4c0ba39deb2679a07f6"><div>
<h3>
<span class="m-doc-wrap-bumper">friend bool </span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ad9423ee067d0a4c0ba39deb2679a07f6">operator==</a>(</span><span class="m-doc-wrap"><a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> lhs,
<a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a> rhs) <span class="m-label m-primary">constexpr</span> <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Equality operator.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">lhs</td>
<td>The LHS <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a>.</td>
</tr>
<tr>
<td>rhs</td>
<td>The RHS <a class="m-doc" href="structtoml_1_1time__offset.html">time_<wbr/>offset</a>.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>True if the time_offsets represented the same value.</td>
</tr>
</tfoot>
</table>
</div></section>
</section>
</div>
</div>
</div>