general/tomlplusplus
2
0
Fork 0
mirror of https://github.com/marzer/tomlplusplus.git synced 2026-02-20 15:22:13 +00:00
Code Issues Projects Releases Wiki Activity
Files
571fc2563ed7bf6413355f91a714a8832bc94c7d
tomlplusplus/classtoml_1_1node.html
ci-build 573b08a2b1 [skip ci] Updates
2020-07-19 23:27:48 +00:00

651 lines
56 KiB
HTML
Raw Blame History

<!DOCTYPE html>
<html lang="en"><head>
<meta charset="utf-8"/>
<title>toml::node class | toml++ TOML
for
modern
C++</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.ico" rel="icon" type="image/vnd.microsoft.icon"/>
<meta content="width=device-width, initial-scale=1.0" name="viewport"/>
<meta content="#22272e" name="theme-color"/>
<meta content="gbtcNgKlNiPSMKkYMw4zWFVWGPH_oU93m9n_-nb4qK8" name="google-site-verification"/>
<meta content="Header-only
TOML
config
file
parser
and
serializer
for
modern
C++." name="description"/>
<script src="tomlplusplus.js"></script>
</head>
<body>
<header><nav id="navigation">
<div class="m-container">
<div class="m-row">
<a class="m-col-t-8 m-col-m-none m-left-m" href="index.html" id="m-navbar-brand"><img alt="" src="logo.png"/>toml++ <span class="m-thin">TOML
for
modern
C++</span></a>
<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 class="github tpp-external" 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>
<span class="m-breadcrumb"><a href="namespacetoml.html">toml</a>::<wbr/></span>node <span class="m-thin">class</span>
</h1>
<p>A TOML node.</p>
<div class="m-block m-default">
<h3>Contents</h3>
<ul>
<li>
Reference
<ul>
<li><a href="#derived-classes">Derived classes</a></li>
<li><a href="#pub-methods">Public functions</a></li>
</ul>
</li>
</ul>
</div>
<p>A parsed TOML document forms a tree made up of tables, arrays and values. This type is the base of each of those, providing a lot of the polymorphic plumbing.</p>
<section id="derived-classes">
<h2><a href="#derived-classes">Derived classes</a></h2>
<dl class="m-doc">
<dt>
class <a class="m-doc" href="classtoml_1_1array.html">array</a> <span class="m-label m-flat m-warning">final</span>
</dt>
<dd>A TOML array.</dd>
<dt>
class <a class="m-doc" href="classtoml_1_1table.html">table</a> <span class="m-label m-flat m-warning">final</span>
</dt>
<dd>A TOML table.</dd>
<dt>
<div class="m-doc-template">template&lt;typename ValueType&gt;</div>
class <a class="m-doc" href="classtoml_1_1value.html">value</a> <span class="m-label m-flat m-warning">final</span>
</dt>
<dd>A TOML value.</dd>
</dl>
</section>
<section id="pub-methods">
<h2><a href="#pub-methods">Public functions</a></h2>
<dl class="m-doc">
<dt id="a21d7481eabdf0eaedb91ddeefa950cc1">
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a21d7481eabdf0eaedb91ddeefa950cc1">as</a>(</span><span class="m-doc-wrap">) const -&gt; const impl::wrap_node&lt;T&gt;* <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a pointer to the node as a more specific node 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="#aa818a12fc0212e5e416b38fcf103f899">as</a>(</span><span class="m-doc-wrap">) -&gt; impl::wrap_node&lt;T&gt;* <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a pointer to the node as a more specific node type.</dd>
<dt id="adac204f1c1e3ae99beaa79bb1624cc95">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#adac204f1c1e3ae99beaa79bb1624cc95">as_array</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1array.html">array</a>* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc" href="classtoml_1_1array.html">toml::<wbr/>array</a>, if it is one.</dd>
<dt id="a40031abf671512f9fdcd31666ce481fd">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a40031abf671512f9fdcd31666ce481fd">as_boolean</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1value.html">toml::<wbr/>value</a>&lt;bool&gt;* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc tpp-injected" href="classtoml_1_1value.html">toml::value</a>&lt;bool&gt;, if it is one.</dd>
<dt id="a35ec7bd4efab69906d7874df736cdaaf">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a35ec7bd4efab69906d7874df736cdaaf">as_date</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1value.html">toml::<wbr/>value</a>&lt;<a class="m-doc" href="structtoml_1_1date.html">date</a>&gt;* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc tpp-injected" href="classtoml_1_1value.html">toml::value</a>&lt;date&gt;, if it is one.</dd>
<dt id="a68cc63dfd8e435b00c7c99da298d6733">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a68cc63dfd8e435b00c7c99da298d6733">as_date_time</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1value.html">toml::<wbr/>value</a>&lt;<a class="m-doc" href="structtoml_1_1date__time.html">date_<wbr/>time</a>&gt;* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc tpp-injected" href="classtoml_1_1value.html">toml::value</a>&lt;date_time&gt;, if it is one.</dd>
<dt id="a480ae95e180992d152ad80e3b52a330a">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a480ae95e180992d152ad80e3b52a330a">as_floating_point</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1value.html">toml::<wbr/>value</a>&lt;double&gt;* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc tpp-injected" href="classtoml_1_1value.html">toml::value</a>&lt;double&gt;, if it is one.</dd>
<dt id="ac507d02b3b744e0624c504614e91c9e5">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ac507d02b3b744e0624c504614e91c9e5">as_integer</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1value.html">toml::<wbr/>value</a>&lt;<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a>&gt;* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a toml::value&lt;<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a>&gt;, if it is one.</dd>
<dt id="ab8f42ecf095260b1d97363949a98267b">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ab8f42ecf095260b1d97363949a98267b">as_string</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1value.html">toml::<wbr/>value</a>&lt;<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::string</a>&gt;* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc tpp-injected" href="classtoml_1_1value.html">toml::value</a>&lt;string&gt;, if it is one.</dd>
<dt id="aa696716239e7434145103173e880fb80">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aa696716239e7434145103173e880fb80">as_table</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1table.html">table</a>* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc" href="classtoml_1_1table.html">toml::<wbr/>table</a>, if it is one.</dd>
<dt id="aeb23a8054899c4b0d57e10c4a3dcadf0">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aeb23a8054899c4b0d57e10c4a3dcadf0">as_time</a>(</span><span class="m-doc-wrap">) -&gt; <a class="m-doc" href="classtoml_1_1value.html">toml::<wbr/>value</a>&lt;<a class="m-doc" href="structtoml_1_1time.html">time</a>&gt;* <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns a pointer to the node as a <a class="m-doc tpp-injected" href="classtoml_1_1value.html">toml::value</a>&lt;time&gt;, if it is one.</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="#a03e1bbe1a0640953b7105fe40c733118">is</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 a node is a specific type.</dd>
<dt id="accce7655b0cc340591a755412fde2ed7">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#accce7655b0cc340591a755412fde2ed7">is_array</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">pure virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is an array.</dd>
<dt id="a1697f7da1cd6a5e4c3d3e25e08274b34">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a1697f7da1cd6a5e4c3d3e25e08274b34">is_array_of_tables</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is an array containing only tables.</dd>
<dt id="a47ca3bd6392029a065f13c029b2db0b2">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a47ca3bd6392029a065f13c029b2db0b2">is_boolean</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a boolean value.</dd>
<dt id="a6e6060cb1233b87d7b57a2a203891d2a">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a6e6060cb1233b87d7b57a2a203891d2a">is_date</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a local <a class="m-doc tpp-injected" href="structtoml_1_1date.html">date</a> value.</dd>
<dt id="a9115204bee51ac6ef962dd9d47bf1b7e">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a9115204bee51ac6ef962dd9d47bf1b7e">is_date_time</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a date-<a class="m-doc tpp-injected" href="structtoml_1_1time.html">time</a> value.</dd>
<dt id="a3ea1296a95c43125119a6fe26af5b014">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a3ea1296a95c43125119a6fe26af5b014">is_floating_point</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is an floating-point value.</dd>
<dt id="a5ecdb684288275ce1786281fbe1845cc">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a5ecdb684288275ce1786281fbe1845cc">is_integer</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is an integer value.</dd>
<dt id="a1db6db67940c59bf0d6f7be184be3511">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a1db6db67940c59bf0d6f7be184be3511">is_number</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is an integer or floating-point value.</dd>
<dt id="aeff35977a4b13fe0fefb9a3b5917f98e">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aeff35977a4b13fe0fefb9a3b5917f98e">is_string</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a string value.</dd>
<dt id="a50a2501af7e42b0fab060206dde7a99e">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a50a2501af7e42b0fab060206dde7a99e">is_table</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">pure virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a table.</dd>
<dt id="a4a7663a4b15650cf833d5c833e313d9b">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a4a7663a4b15650cf833d5c833e313d9b">is_time</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a local <a class="m-doc tpp-injected" href="structtoml_1_1time.html">time</a> value.</dd>
<dt id="aeddf9eebbd4ece799e5675e2d9d59e4a">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aeddf9eebbd4ece799e5675e2d9d59e4a">is_value</a>(</span><span class="m-doc-wrap">) const -&gt; bool <span class="m-label m-flat m-warning">pure virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns true if this node is a value.</dd>
<dt id="a292bce25bfe779dc51403e88f0cc4bcc">
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a292bce25bfe779dc51403e88f0cc4bcc">ref</a>(</span><span class="m-doc-wrap">) &amp;&amp; -&gt; impl::unwrap_node&lt;T&gt;&amp;&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a raw reference to a value node's underlying data (rvalue 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="#a0f2b674e80b882b329513e7ec9aed842">ref</a>(</span><span class="m-doc-wrap">) &amp; -&gt; impl::unwrap_node&lt;T&gt;&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a raw reference to a value node's underlying data.</dd>
<dt id="a378e94ebc00235eb4d1da68f81edd77f">
<div class="m-doc-template">template&lt;typename T&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a378e94ebc00235eb4d1da68f81edd77f">ref</a>(</span><span class="m-doc-wrap">) const &amp; -&gt; const impl::unwrap_node&lt;T&gt;&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets a raw reference to a value node's underlying data (const lvalue overload).</dd>
<dt id="aa378fa343dab7d7bdb4073570dba5fdc">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#aa378fa343dab7d7bdb4073570dba5fdc">source</a>(</span><span class="m-doc-wrap">) const -&gt; const <a class="m-doc" href="structtoml_1_1source__region.html">source_<wbr/>region</a>&amp; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns the source region responsible for generating this node during parsing.</dd>
<dt id="a10f389035ce13abb00a1191358af6334">
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a10f389035ce13abb00a1191358af6334">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">pure virtual</span> <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Returns the node's type identifier.</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="#ab144c1ae90338b6b03f6af0574c87993">value</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="namespacetoml.html#af34a9fb3305e419784104609e6bbb7ac">optional</a>&lt;T&gt; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets the value contained by this node.</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="#a6bad622231925c6855422563c48f1b3c">value_exact</a>(</span><span class="m-doc-wrap">) const -&gt; <a class="m-doc" href="namespacetoml.html#af34a9fb3305e419784104609e6bbb7ac">optional</a>&lt;T&gt; <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets the value contained by this node.</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="#a423ddccc36345545615e20290c9a8a65">value_or</a>(</span><span class="m-doc-wrap">T&amp;&amp; default_value) const -&gt; auto <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Gets the raw value contained by this node, or a default.</dd>
<dt id="a371a03c4b91cfbb8d9ee785c1eacf836">
<div class="m-doc-template">template&lt;typename Func&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#a371a03c4b91cfbb8d9ee785c1eacf836">visit</a>(</span><span class="m-doc-wrap">Func&amp;&amp; visitor) &amp;&amp; -&gt; decltype(auto) <span class="m-label m-flat m-success">noexcept(…)</span></span>
</dt>
<dd>Invokes a visitor on the node based on the node's concrete type (rvalue overload).</dd>
<dt>
<div class="m-doc-template">template&lt;typename Func&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc" href="#ad47390f3832260db7bf06cd282598240">visit</a>(</span><span class="m-doc-wrap">Func&amp;&amp; visitor) &amp; -&gt; decltype(auto) <span class="m-label m-flat m-success">noexcept(…)</span></span>
</dt>
<dd>Invokes a visitor on the node based on the node's concrete type.</dd>
<dt id="ad4a42e50f923b0fe1efff0a6719dab90">
<div class="m-doc-template">template&lt;typename Func&gt;</div>
<span class="m-doc-wrap-bumper">auto <a class="m-doc-self" href="#ad4a42e50f923b0fe1efff0a6719dab90">visit</a>(</span><span class="m-doc-wrap">Func&amp;&amp; visitor) const &amp; -&gt; decltype(auto) <span class="m-label m-flat m-success">noexcept(…)</span></span>
</dt>
<dd>Invokes a visitor on the node based on the node's concrete type (const lvalue overload).</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-doc-details" id="aa818a12fc0212e5e416b38fcf103f899"><div>
<h3>
<div class="m-doc-template">
template&lt;typename T&gt;
</div>
<span class="m-doc-wrap-bumper">impl::wrap_node&lt;T&gt;* toml::<wbr/>node::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#aa818a12fc0212e5e416b38fcf103f899">as</a>(</span><span class="m-doc-wrap">) <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets a pointer to the node as a more specific node 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 type or TOML value type to cast to.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A pointer to the node as the given type, or nullptr if it was a different type.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="ns">toml::</span><span class="ut">value</span><span class="o">&lt;</span><span class="ut"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a></span><span class="o">&gt;*</span> <span class="n">int_value</span> <span class="o">=</span> <span class="ut">node</span><span class="o">-&gt;</span><span class="n">as</span><span class="o">&lt;</span><span class="ut"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a></span><span class="o">&gt;</span><span class="p">();</span>
<span class="ns">toml::</span><span class="ut">table</span><span class="o">*</span> <span class="n">tbl</span> <span class="o">=</span> <span class="ut">node</span><span class="o">-&gt;</span><span class="n">as</span><span class="o">&lt;</span><span class="ns">toml::</span><span class="ut">table</span><span class="o">&gt;</span><span class="p">();</span>
<span class="k">if</span> <span class="p">(</span><span class="n">int_value</span><span class="p">)</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Node is a value&lt;<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a>&gt;"</span> <span class="o">&lt;&lt;</span> <span class="ns">std::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">tbl</span><span class="p">)</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Node is a table"</span> <span class="o">&lt;&lt;</span> <span class="ns">std::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// fully-qualified value node types also work (useful for template code):</span>
<span class="ns">toml::</span><span class="ut">value</span><span class="o">&lt;</span><span class="ut"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a></span><span class="o">&gt;*</span> <span class="n">int_value2</span> <span class="o">=</span> <span class="ut">node</span><span class="o">-&gt;</span><span class="n">as</span><span class="o">&lt;</span><span class="ns">toml::</span><span class="ut">value</span><span class="o">&lt;</span><span class="ut"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a></span><span class="o">&gt;&gt;</span><span class="p">();</span>
<span class="k">if</span> <span class="p">(</span><span class="n">int_value2</span><span class="p">)</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Node is a value&lt;<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a>&gt;"</span> <span class="o">&lt;&lt;</span> <span class="ns">std::</span><span class="n">endl</span><span class="p">;</span></pre>
</div></section>
<section class="m-doc-details" id="a03e1bbe1a0640953b7105fe40c733118"><div>
<h3>
<div class="m-doc-template">
template&lt;typename T&gt;
</div>
<span class="m-doc-wrap-bumper">bool toml::<wbr/>node::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a03e1bbe1a0640953b7105fe40c733118">is</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Checks if a node is a specific 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>A TOML node or value type.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>Returns true if this node is an instance of the specified type.</td>
</tr>
</tfoot>
</table>
</div></section>
<section class="m-doc-details" id="a0f2b674e80b882b329513e7ec9aed842"><div>
<h3>
<div class="m-doc-template">
template&lt;typename T&gt;
</div>
<span class="m-doc-wrap-bumper">impl::unwrap_node&lt;T&gt;&amp; toml::<wbr/>node::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a0f2b674e80b882b329513e7ec9aed842">ref</a>(</span><span class="m-doc-wrap">) &amp; <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets a raw reference to a value node's underlying data.</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>One of the TOML value types.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>A reference to the underlying data.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-danger"><h4>Warning</h4><p>This function is dangerous if used carelessly and <strong>WILL</strong> break your code if the chosen value type doesn't match the node's actual type. In debug builds an assertion will fire when invalid accesses are attempted:</p><pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="ns">toml::</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"> min = 32</span>
<span class="s"> max = 45</span>
<span class="dl">)</span><span class="s">"</span><span class="sa">sv</span><span class="p">);</span>
<span class="ut"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a></span><span class="o">&amp;</span> <span class="n">min_ref</span> <span class="o">=</span> <span class="n">tbl</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">"min"</span><span class="p">)</span><span class="o">-&gt;</span><span class="n">ref</span><span class="o">&lt;</span><span class="ut"><a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a></span><span class="o">&gt;</span><span class="p">();</span> <span class="c1">// matching type</span>
<span class="ut">double</span><span class="o">&amp;</span> <span class="n">max_ref</span> <span class="o">=</span> <span class="n">tbl</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="s">"max"</span><span class="p">)</span><span class="o">-&gt;</span><span class="n">ref</span><span class="o">&lt;</span><span class="ut">double</span><span class="o">&gt;</span><span class="p">();</span> <span class="c1">// mismatched type, hits assert()</span></pre></aside>
</div></section>
<section class="m-doc-details" id="ab144c1ae90338b6b03f6af0574c87993"><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#af34a9fb3305e419784104609e6bbb7ac">optional</a>&lt;T&gt; toml::<wbr/>node::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ab144c1ae90338b6b03f6af0574c87993">value</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets the value contained by this node.</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>One of the native TOML value types, or a type capable of converting to one.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>The underlying value if the node was a value of the matching type (or convertible to it) and within the range of the output type, or an empty optional.</td>
</tr>
</tfoot>
</table>
<p>This function has 'permissive' retrieval semantics; some value types are allowed to convert to others (e.g. retrieving a boolean as an integer), and the specified return value type can be any type where a reasonable conversion from a native TOML value exists (e.g. <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::wstring</a> on Windows). If the source value cannot be represented by the destination type, an empty optional is returned.</p><pre class="m-code"><span class="k">auto</span> <span class="n">tbl</span> <span class="o">=</span> <span class="ns">toml::</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"> int = -10</span>
<span class="s"> flt = 25.0</span>
<span class="s"> pi = 3.14159</span>
<span class="s"> bool = false</span>
<span class="s"> huge = 9223372036854775807</span>
<span class="s"> str = "foo"</span>
<span class="dl">)</span><span class="s">"</span><span class="sa">sv</span><span class="p">);</span>
<span class="k">const</span> <span class="k">auto</span> <span class="n">print_value_with_typename</span> <span class="o">=</span>
<span class="p">[</span><span class="o">&amp;</span><span class="p">](</span><span class="ns">std::</span><span class="ut">string_view</span> <span class="n">key</span><span class="p">,</span> <span class="ns">std::</span><span class="ut">string_view</span> <span class="n">type_name</span><span class="p">,</span> <span class="k">auto</span><span class="o">*</span> <span class="n">dummy</span><span class="p">)</span>
<span class="p">{</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"'"</span> <span class="o">&lt;&lt;</span> <span class="n">key</span> <span class="o">&lt;&lt;</span> <span class="s">"' as "</span> <span class="o">&lt;&lt;</span> <span class="n">type_name</span> <span class="o">&lt;&lt;</span> <span class="s">": "</span><span class="p">;</span>
<span class="k">using</span> <span class="n">type</span> <span class="o">=</span> <span class="ns">std::</span><span class="n">remove_pointer_t</span><span class="o">&lt;</span><span class="k">decltype</span><span class="p">(</span><span class="n">dummy</span><span class="p">)</span><span class="o">&gt;</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span><span class="ns">std::</span><span class="ut">optional</span><span class="o">&lt;</span><span class="n">type</span><span class="o">&gt;</span> <span class="n">val</span> <span class="o">=</span> <span class="n">tbl</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="n">key</span><span class="p">)</span><span class="o">-&gt;</span><span class="ut">value</span><span class="o">&lt;</span><span class="n">type</span><span class="o">&gt;</span><span class="p">())</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="o">*</span><span class="n">val</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="k">else</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"No conversion path or out-of-range</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">};</span>
<span class="cp">#define print_value(key, T) print_value_with_typename(key, #T, (T*)nullptr)</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"int"</span><span class="p">,</span> <span class="ut">bool</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"int"</span><span class="p">,</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"int"</span><span class="p">,</span> <span class="ut">unsigned</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"int"</span><span class="p">,</span> <span class="ut">long</span> <span class="ut">long</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"int"</span><span class="p">,</span> <span class="ut">float</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"int"</span><span class="p">,</span> <span class="ut">double</span><span class="p">);</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"flt"</span><span class="p">,</span> <span class="ut">bool</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"flt"</span><span class="p">,</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"flt"</span><span class="p">,</span> <span class="ut">unsigned</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"flt"</span><span class="p">,</span> <span class="ut">long</span> <span class="ut">long</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"flt"</span><span class="p">,</span> <span class="ut">float</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"flt"</span><span class="p">,</span> <span class="ut">double</span><span class="p">);</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"pi"</span><span class="p">,</span> <span class="ut">bool</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"pi"</span><span class="p">,</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"pi"</span><span class="p">,</span> <span class="ut">unsigned</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"pi"</span><span class="p">,</span> <span class="ut">long</span> <span class="ut">long</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"pi"</span><span class="p">,</span> <span class="ut">float</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"pi"</span><span class="p">,</span> <span class="ut">double</span><span class="p">);</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"bool"</span><span class="p">,</span> <span class="ut">bool</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"bool"</span><span class="p">,</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"bool"</span><span class="p">,</span> <span class="ut">unsigned</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"bool"</span><span class="p">,</span> <span class="ut">long</span> <span class="ut">long</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"bool"</span><span class="p">,</span> <span class="ut">float</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"bool"</span><span class="p">,</span> <span class="ut">double</span><span class="p">);</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"huge"</span><span class="p">,</span> <span class="ut">bool</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"huge"</span><span class="p">,</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"huge"</span><span class="p">,</span> <span class="ut">unsigned</span> <span class="ut">int</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"huge"</span><span class="p">,</span> <span class="ut">long</span> <span class="ut">long</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"huge"</span><span class="p">,</span> <span class="ut">float</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"huge"</span><span class="p">,</span> <span class="ut">double</span><span class="p">);</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"str"</span><span class="p">,</span> <span class="ns">std::</span><span class="ut">string</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"str"</span><span class="p">,</span> <span class="ns">std::</span><span class="ut">string_view</span><span class="p">);</span>
<span class="n">print_value</span><span class="p">(</span><span class="s">"str"</span><span class="p">,</span> <span class="k">const</span> <span class="ut">char</span><span class="o">*</span><span class="p">);</span>
<span class="ns">std::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span></pre><pre class="m-console"><span class="go">'int' as bool: true</span>
<span class="go">'int' as int: -10</span>
<span class="go">'int' as unsigned int: No conversion path or out-of-range</span>
<span class="go">'int' as long long: -10</span>
<span class="go">'int' as float: -10</span>
<span class="go">'int' as double: -10</span>
<span class="go">'flt' as bool: No conversion path or out-of-range</span>
<span class="go">'flt' as int: 25</span>
<span class="go">'flt' as unsigned int: 25</span>
<span class="go">'flt' as long long: 25</span>
<span class="go">'flt' as float: 25</span>
<span class="go">'flt' as double: 25</span>
<span class="go">'pi' as bool: No conversion path or out-of-range</span>
<span class="go">'pi' as int: No conversion path or out-of-range</span>
<span class="go">'pi' as unsigned int: No conversion path or out-of-range</span>
<span class="go">'pi' as long long: No conversion path or out-of-range</span>
<span class="go">'pi' as float: 3.14159</span>
<span class="go">'pi' as double: 3.14159</span>
<span class="go">'bool' as bool: false</span>
<span class="go">'bool' as int: 0</span>
<span class="go">'bool' as unsigned int: 0</span>
<span class="go">'bool' as long long: 0</span>
<span class="go">'bool' as float: No conversion path or out-of-range</span>
<span class="go">'bool' as double: No conversion path or out-of-range</span>
<span class="go">'huge' as bool: true</span>
<span class="go">'huge' as int: No conversion path or out-of-range</span>
<span class="go">'huge' as unsigned int: No conversion path or out-of-range</span>
<span class="go">'huge' as long long: 9223372036854775807</span>
<span class="go">'huge' as float: No conversion path or out-of-range</span>
<span class="go">'huge' as double: No conversion path or out-of-range</span>
<span class="go">'str' as <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::string</a>: foo</span>
<span class="go">'str' as <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>: foo</span>
<span class="go">'str' as const char*: foo</span></pre><aside class="m-note m-warning"><h4>Attention</h4><p>If you want strict value retrieval semantics that do not allow for any type conversions, use <a class="m-doc" href="classtoml_1_1node.html#a6bad622231925c6855422563c48f1b3c">node::<wbr/>value_exact()</a> instead.</p></aside><aside class="m-note m-default"><h4>See also</h4><p><a class="m-doc" href="classtoml_1_1node.html#a6bad622231925c6855422563c48f1b3c">node::<wbr/>value_exact()</a></p></aside>
</div></section>
<section class="m-doc-details" id="a6bad622231925c6855422563c48f1b3c"><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#af34a9fb3305e419784104609e6bbb7ac">optional</a>&lt;T&gt; toml::<wbr/>node::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a6bad622231925c6855422563c48f1b3c">value_exact</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets the value contained by this node.</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>One of the native TOML value types, or a type capable of losslessly representing one.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>The underlying value if the node was a value of the matching type (or losslessly convertible to it), or an empty optional.</td>
</tr>
</tfoot>
</table>
<p>This function has 'exact' retrieval semantics; the only return value types allowed are the TOML native value types, or types that can losslessly represent a native value type (e.g. <a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::wstring</a> on Windows).</p><aside class="m-note m-default"><h4>See also</h4><p><a class="m-doc" href="classtoml_1_1node.html#ab144c1ae90338b6b03f6af0574c87993">node::<wbr/>value()</a></p></aside>
</div></section>
<section class="m-doc-details" id="a423ddccc36345545615e20290c9a8a65"><div>
<h3>
<div class="m-doc-template">
template&lt;typename T&gt;
</div>
<span class="m-doc-wrap-bumper">auto toml::<wbr/>node::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#a423ddccc36345545615e20290c9a8a65">value_or</a>(</span><span class="m-doc-wrap">T&amp;&amp; default_value) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Gets the raw value contained by this node, or a default.</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>Default value type. Must be one of the native TOML value types, or convertible to it.</td>
</tr>
</tbody>
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td>default_value</td>
<td>The default value to return if the node wasn't a value, wasn't the correct type, or no conversion was possible.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>The underlying value if the node was a value of the matching type (or convertible to it) and within the range of the output type, or the provided default.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-warning"><h4>Attention</h4><p>This function has the same permissive retrieval semantics as <a class="m-doc" href="classtoml_1_1node.html#ab144c1ae90338b6b03f6af0574c87993">node::<wbr/>value()</a>. If you want strict value retrieval semantics that do not allow for any type conversions, use <a class="m-doc" href="classtoml_1_1node.html#a6bad622231925c6855422563c48f1b3c">node::<wbr/>value_exact()</a> instead.</p></aside><aside class="m-note m-default"><h4>See also</h4><ul><li><a class="m-doc" href="classtoml_1_1node.html#ab144c1ae90338b6b03f6af0574c87993">node::<wbr/>value()</a></li><li><a class="m-doc" href="classtoml_1_1node.html#a6bad622231925c6855422563c48f1b3c">node::<wbr/>value_exact()</a></li></ul></aside>
</div></section>
<section class="m-doc-details" id="ad47390f3832260db7bf06cd282598240"><div>
<h3>
<div class="m-doc-template">
template&lt;typename Func&gt;
</div>
<span class="m-doc-wrap-bumper">decltype(auto) toml::<wbr/>node::<wbr/></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a class="m-doc-self" href="#ad47390f3832260db7bf06cd282598240">visit</a>(</span><span class="m-doc-wrap">Func&amp;&amp; visitor) &amp; <span class="m-label m-success">noexcept(…)</span></span></span>
</h3>
<p>Invokes a visitor on the node based on the node's concrete 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%">Func</td>
<td>A callable type invocable with one or more of the toml++ node types.</td>
</tr>
</tbody>
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td>visitor</td>
<td>The visitor object.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>The return value of the visitor. Can be void. Non-exhaustive visitors must return a default-constructible type.</td>
</tr>
</tfoot>
</table>
<p>Visitation is useful when you expect a node to be one of a set number of types and need to handle these types differently. Using <code><a class="m-doc" href="classtoml_1_1node.html#ad47390f3832260db7bf06cd282598240">visit()</a></code> allows you to eliminate some of the casting/conversion boilerplate:</p><pre class="m-code"><span class="ut">node</span><span class="p">.</span><span class="n">visit</span><span class="p">([](</span><span class="k">auto</span><span class="o">&amp;&amp;</span> <span class="n">n</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="k">constexpr</span> <span class="p">(</span><span class="ns">toml::</span><span class="n">is_string</span><span class="o">&lt;</span><span class="k">decltype</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="o">&gt;</span><span class="p">)</span>
<span class="n">do_something_with_a_string</span><span class="p">(</span><span class="o">*</span><span class="n">n</span><span class="p">));</span> <span class="c1">//n is a toml::value&lt;<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/string/basic_string" target="_blank">std::string</a>&gt;</span>
<span class="k">else</span> <span class="k">if</span> <span class="k">constexpr</span> <span class="p">(</span><span class="ns">toml::</span><span class="n">is_integer</span><span class="o">&lt;</span><span class="k">decltype</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="o">&gt;</span><span class="p">)</span>
<span class="n">do_something_with_an_int</span><span class="p">(</span><span class="o">*</span><span class="n">n</span><span class="p">);</span> <span class="c1">//n is a toml::value&lt;<a class="m-doc tpp-injected tpp-external" href="https://en.cppreference.com/w/cpp/types/integer" target="_blank">int64_t</a>&gt;</span>
<span class="k">else</span>
<span class="k">throw</span> <span class="ns">std::</span><span class="ut">exception</span><span class="p">{</span> <span class="s">"Expected string or integer"</span> <span class="p">};</span>
<span class="p">});</span></pre><aside class="m-note m-default"><h4>See also</h4><p><a class="tpp-external" href="https://en.wikipedia.org/wiki/Visitor_pattern" target="_blank">https://en.wikipedia.org/wiki/Visitor_<wbr/>pattern</a></p></aside>
</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 class="tpp-external" href="https://github.com/marzer/tomlplusplus/" target="_blank">Github</a>
•
<a class="tpp-external" href="https://github.com/marzer/tomlplusplus/issues" target="_blank">Report
an
issue</a>
<br/><br/>Documentation
generated
using
<a class="tpp-external" href="https://mcss.mosra.cz/" target="_blank">m.css</a>
</div>
</div>
</div>
</nav></footer>
</body></html>
Reference in New Issue View Git Blame Copy Permalink