zhangyiss/toml11
1
0
Fork 0
mirror of https://github.com/ToruNiina/toml11.git synced 2025-12-16 03:08:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
gh-pages
toml11/docs/reference/result/index.html
ToruNiina 360850a8c8 Merge pull request #295 from franzpoeschel/undef-source-location 
Add a way to optionally suppress usage of std::source_location b96acf96ba
2025-12-03 15:01:09 +00:00

313 lines
63 KiB
HTML
Raw Permalink Blame History

<!doctype html><html lang=en dir=ltr><head><meta charset=UTF-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=description content="
result.hpp
#
result.hpp defines the result type, which can hold either a success value or a failure value.
This is used as the return type for toml::try_parse, which does not throw exceptions.
success
#
A type that holds a success value.
namespace toml
{
template<typename T>
struct success
{
using value_type = T;
explicit success(value_type v);
~success() = default;
success(const success&) = default;
success(success&&) = default;
success& operator=(const success&) = default;
success& operator=(success&&) = default;
template<typename U>
explicit success(U&& v);
template<typename U>
explicit success(success<U> v);
value_type& get() noexcept;
value_type const& get() const noexcept;
};
template<typename T>
success<typename std::decay<T>::type> ok(T&& v);
template<std::size_t N>
success<std::string> ok(const char (&amp;literal)[N])
}
Member Types
#
using value_type = T;
The type of the success value."><meta name=theme-color media="(prefers-color-scheme: light)" content="#ffffff"><meta name=theme-color media="(prefers-color-scheme: dark)" content="#343a40"><meta name=color-scheme content="light dark"><meta property="og:url" content="https://toruniina.github.io/toml11/docs/reference/result/"><meta property="og:site_name" content="toml11"><meta property="og:title" content="result.hpp"><meta property="og:description" content="result.hpp # result.hpp defines the result type, which can hold either a success value or a failure value.
This is used as the return type for toml::try_parse, which does not throw exceptions.
success # A type that holds a success value.
namespace toml { template<typename T> struct success { using value_type = T; explicit success(value_type v); ~success() = default; success(const success&) = default; success(success&&) = default; success& operator=(const success&) = default; success& operator=(success&&) = default; template<typename U> explicit success(U&& v); template<typename U> explicit success(success<U> v); value_type& get() noexcept; value_type const& get() const noexcept; }; template<typename T> success<typename std::decay<T>::type> ok(T&& v); template<std::size_t N> success<std::string> ok(const char (&amp;literal)[N]) } Member Types # using value_type = T; The type of the success value."><meta property="og:locale" content="en"><meta property="og:type" content="article"><meta property="article:section" content="docs"><title>result.hpp | toml11</title><link rel=manifest href=/toml11/manifest.json><link rel=icon href=/toml11/favicon.png><link rel=canonical href=https://toruniina.github.io/toml11/docs/reference/result/><link rel=alternate hreflang=ja href=https://toruniina.github.io/toml11/ja/docs/reference/result/ title=result.hpp><link rel=stylesheet href=/toml11/book.min.6d8037b375fe949eee1b70501c5fb9478914c9c5eb3ef7696163fd3031c69421.css integrity="sha256-bYA3s3X+lJ7uG3BQHF+5R4kUycXrPvdpYWP9MDHGlCE=" crossorigin=anonymous><script defer src=/toml11/fuse.min.js></script><script defer src=/toml11/en.search.min.87bec23503963d7026bfa3a917b92707789d315c9c9e005e23226b35dce643f5.js integrity="sha256-h77CNQOWPXAmv6OpF7knB3idMVycngBeIyJrNdzmQ/U=" crossorigin=anonymous></script></head><body dir=ltr><input type=checkbox class="hidden toggle" id=menu-control>
<input type=checkbox class="hidden toggle" id=toc-control><main class="container flex"><aside class=book-menu><div class=book-menu-content><nav><h2 class=book-brand><a class="flex align-center" href=/toml11/><span>toml11</span></a></h2><div class="book-search hidden"><input type=text id=book-search-input placeholder=Search aria-label=Search maxlength=64 data-hotkeys=s/><div class="book-search-spinner hidden"></div><ul id=book-search-results></ul></div><script>document.querySelector(".book-search").classList.remove("hidden")</script><ul class=book-languages><li><input type=checkbox id=languages class=toggle>
<label for=languages class="flex justify-between"><a role=button class="flex align-center"><img src=/toml11/svg/translate.svg class=book-icon alt=Languages>
English</a></label><ul><li><a href=https://toruniina.github.io/toml11/ja/docs/reference/result/>日本語</a></li></ul></li></ul><ul><li><a href=/toml11/docs/installation/>installation</a><ul></ul></li><li><input type=checkbox id=section-291123c850af98d8b815ccdbb4c33657 class=toggle>
<label for=section-291123c850af98d8b815ccdbb4c33657 class="flex justify-between"><a href=/toml11/docs/features/>features</a></label><ul><li><a href=/toml11/docs/features/parsing_files/>parsing files</a></li><li><a href=/toml11/docs/features/value/>getting values</a></li><li><a href=/toml11/docs/features/error_message/>error message</a></li><li><a href=/toml11/docs/features/serialize/>serializing values</a></li><li><a href=/toml11/docs/features/configure_types/>configuring types</a></li><li><a href=/toml11/docs/features/literal/>toml literal</a></li><li><a href=/toml11/docs/features/toml_spec/>toml spec</a></li><li><a href=/toml11/docs/features/extension/>extension</a></li></ul></li><li><input type=checkbox id=section-e2e812e55021b82e114feaae98f1a02e class=toggle checked>
<label for=section-e2e812e55021b82e114feaae98f1a02e class="flex justify-between"><a href=/toml11/docs/reference/>reference</a></label><ul><li><a href=/toml11/docs/reference/color/>color.hpp</a></li><li><a href=/toml11/docs/reference/comments/>comments.hpp</a></li><li><a href=/toml11/docs/reference/conversion/>conversion.hpp</a></li><li><a href=/toml11/docs/reference/datetime/>datetime.hpp</a></li><li><a href=/toml11/docs/reference/error_info/>error_info.hpp</a></li><li><a href=/toml11/docs/reference/exception/>exception.hpp</a></li><li><a href=/toml11/docs/reference/find/>find.hpp</a></li><li><a href=/toml11/docs/reference/format/>format.hpp</a></li><li><a href=/toml11/docs/reference/from/>from.hpp</a></li><li><a href=/toml11/docs/reference/get/>get.hpp</a></li><li><a href=/toml11/docs/reference/into/>into.hpp</a></li><li><a href=/toml11/docs/reference/literal/>literal.hpp</a></li><li><a href=/toml11/docs/reference/ordered_map/>ordered_map.hpp</a></li><li><a href=/toml11/docs/reference/parser/>parser.hpp</a></li><li><a href=/toml11/docs/reference/result/ class=active>result.hpp</a></li><li><a href=/toml11/docs/reference/serializer/>serializer.hpp</a></li><li><a href=/toml11/docs/reference/source_location/>source_location.hpp</a></li><li><a href=/toml11/docs/reference/spec/>spec.hpp</a></li><li><a href=/toml11/docs/reference/toml_fwd/>toml_fwd.hpp</a></li><li><a href=/toml11/docs/reference/toml/>toml.hpp</a></li><li><a href=/toml11/docs/reference/types/>types.hpp</a></li><li><a href=/toml11/docs/reference/value_t/>value_t.hpp</a></li><li><a href=/toml11/docs/reference/value/>value.hpp</a></li><li><a href=/toml11/docs/reference/version/>version.hpp</a></li><li><a href=/toml11/docs/reference/visit/>visit.hpp</a></li></ul></li><li><a href=/toml11/docs/changelog/>changelog</a><ul></ul></li></ul><ul><li><a href=https://github.com/ToruNiina/toml11 target=_blank rel=noopener>GitHub</a></li></ul></nav><script>(function(){var e=document.querySelector("aside .book-menu-content");addEventListener("beforeunload",function(){localStorage.setItem("menu.scrollTop",e.scrollTop)}),e.scrollTop=localStorage.getItem("menu.scrollTop")})()</script></div></aside><div class=book-page><header class=book-header><div class="flex align-center justify-between"><label for=menu-control><img src=/toml11/svg/menu.svg class=book-icon alt=Menu>
</label><strong>result.hpp</strong>
<label for=toc-control><img src=/toml11/svg/toc.svg class=book-icon alt="Table of Contents"></label></div><aside class="hidden clearfix"><nav id=TableOfContents><ul><li><a href=#resulthpp>result.hpp</a></li><li><a href=#success>success</a><ul><li><a href=#member-types>Member Types</a></li><li><a href=#member-functions>Member Functions</a><ul><li><a href=#constructor>Constructor</a></li><li><a href=#get><code>get()</code></a></li></ul></li><li><a href=#non-member-functions>Non-Member Functions</a><ul><li><a href=#okt><code>ok(T)</code></a></li></ul></li></ul></li><li><a href=#successreference_wrappert><code>success&lt;reference_wrapper&lt;T>></code></a><ul><li><a href=#member-types-1>Member Types</a><ul><li><a href=#get-1><code>get()</code></a></li></ul></li></ul></li><li><a href=#failure>failure</a><ul><li><a href=#member-types-2>Member Types</a></li><li><a href=#member-functions-1>Member Functions</a><ul><li><a href=#constructor-1>Constructor</a></li><li><a href=#get-2><code>get()</code></a></li></ul></li><li><a href=#non-member-functions-1>Non-Member Functions</a><ul><li><a href=#errt><code>err(T)</code></a></li></ul></li></ul></li><li><a href=#failurereference_wrappert><code>failure&lt;reference_wrapper&lt;T>></code></a><ul><li><a href=#member-types-3>Member Types</a><ul><li><a href=#get-3><code>get()</code></a></li></ul></li></ul></li><li><a href=#result>result</a><ul><li><a href=#member-types-4>Member Types</a><ul><li><a href=#success_type><code>success_type</code></a></li><li><a href=#failure_type><code>failure_type</code></a></li><li><a href=#value_type><code>value_type</code></a></li><li><a href=#error_type><code>error_type</code></a></li></ul></li><li><a href=#member-functions-2>Member Functions</a><ul><li><a href=#constructor-2>Constructor</a></li><li><a href=#copy-and-move-constructors>Copy and Move Constructors</a></li><li><a href=#operator><code>operator=</code></a></li><li><a href=#is_ok><code>is_ok()</code></a></li><li><a href=#is_err><code>is_err()</code></a></li><li><a href=#operator-bool><code>operator bool()</code></a></li><li><a href=#unwrap><code>unwrap()</code></a></li><li><a href=#unwrap_or><code>unwrap_or()</code></a></li><li><a href=#unwrap_err><code>unwrap_err()</code></a></li><li><a href=#as_ok><code>as_ok()</code></a></li><li><a href=#as_err><code>as_err()</code></a></li></ul></li></ul></li><li><a href=#bad_result_access>bad_result_access</a></li></ul></nav></aside></header><article class="markdown book-article"><h1 id=resulthpp>result.hpp
<a class=anchor href=#resulthpp>#</a></h1><p><code>result.hpp</code> defines the <code>result</code> type, which can hold either a success value or a failure value.</p><p>This is used as the return type for <code>toml::try_parse</code>, which does not throw exceptions.</p><h1 id=success>success
<a class=anchor href=#success>#</a></h1><p>A type that holds a success value.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>namespace</span> toml
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>success</span>
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> <span style=color:#a6e22e>success</span>(value_type v);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#f92672>~</span>success() <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> success(<span style=color:#66d9ef>const</span> success<span style=color:#f92672>&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> success(success<span style=color:#f92672>&amp;&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> success<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(<span style=color:#66d9ef>const</span> success<span style=color:#f92672>&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> success<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(success<span style=color:#f92672>&amp;&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> success(U<span style=color:#f92672>&amp;&amp;</span> v);
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> success(success<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> v);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span> value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>};
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>success<span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> std<span style=color:#f92672>::</span>decay<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;::</span>type<span style=color:#f92672>&gt;</span> ok(T<span style=color:#f92672>&amp;&amp;</span> v);
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>size_t N<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>success<span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>string<span style=color:#f92672>&gt;</span> ok(<span style=color:#66d9ef>const</span> <span style=color:#66d9ef>char</span> (<span style=color:#f92672>&amp;</span>literal)[N])
</span></span><span style=display:flex><span>}
</span></span></code></pre></div><h2 id=member-types>Member Types
<a class=anchor href=#member-types>#</a></h2><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span></code></pre></div><p>The type of the success value.</p><h2 id=member-functions>Member Functions
<a class=anchor href=#member-functions>#</a></h2><h3 id=constructor>Constructor
<a class=anchor href=#constructor>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>explicit</span> <span style=color:#a6e22e>success</span>(value_type v);
</span></span></code></pre></div><p>Constructs with a <code>value_type</code> argument.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>explicit</span> success(U<span style=color:#f92672>&amp;&amp;</span> v);
</span></span></code></pre></div><p>Constructs with another type that can be converted to <code>value_type</code>.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>explicit</span> success(success<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> v);
</span></span></code></pre></div><p>Constructs with another <code>success</code> type that can be converted to <code>value_type</code>.</p><h3 id=get><code>get()</code>
<a class=anchor href=#get>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Accesses the stored value.</p><h2 id=non-member-functions>Non-Member Functions
<a class=anchor href=#non-member-functions>#</a></h2><h3 id=okt><code>ok(T)</code>
<a class=anchor href=#okt>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>success<span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> std<span style=color:#f92672>::</span>decay<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;::</span>type<span style=color:#f92672>&gt;</span> ok(T<span style=color:#f92672>&amp;&amp;</span> v);
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>size_t N<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>success<span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>string<span style=color:#f92672>&gt;</span> ok(<span style=color:#66d9ef>const</span> <span style=color:#66d9ef>char</span> (<span style=color:#f92672>&amp;</span>literal)[N]);
</span></span></code></pre></div><p>Constructs and returns a <code>success</code> type from a success value.</p><p>Converts a string literal into <code>std::string</code>.</p><h1 id=successreference_wrappert><code>success&lt;reference_wrapper&lt;T>></code>
<a class=anchor href=#successreference_wrappert>#</a></h1><p>Specialization of <code>success</code> for when the success value is a reference.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>namespace</span> toml
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>success</span><span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>reference_wrapper<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;&gt;</span>
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> <span style=color:#a6e22e>success</span>(std<span style=color:#f92672>::</span>reference_wrapper<span style=color:#f92672>&lt;</span>value_type<span style=color:#f92672>&gt;</span> v) <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span> value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>};
</span></span><span style=display:flex><span>}
</span></span></code></pre></div><h2 id=member-types-1>Member Types
<a class=anchor href=#member-types-1>#</a></h2><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span></code></pre></div><p>The type of the success value. It is <code>T</code> from <code>std::reference_wrapper&lt;T></code>, not the reference itself.</p><h3 id=get-1><code>get()</code>
<a class=anchor href=#get-1>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Accesses the stored value.</p><h1 id=failure>failure
<a class=anchor href=#failure>#</a></h1><p>A type that holds a failure value.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>namespace</span> toml
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>failure</span>
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> <span style=color:#a6e22e>failure</span>(value_type v);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#f92672>~</span>failure() <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> failure(<span style=color:#66d9ef>const</span> failure<span style=color:#f92672>&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> failure(failure<span style=color:#f92672>&amp;&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> failure<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(<span style=color:#66d9ef>const</span> failure<span style=color:#f92672>&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> failure<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(failure<span style=color:#f92672>&amp;&amp;</span>) <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> failure(U<span style=color:#f92672>&amp;&amp;</span> v);
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> failure(failure<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> v);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span> value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>};
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>failure<span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> std<span style=color:#f92672>::</span>decay<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;::</span>type<span style=color:#f92672>&gt;</span> err(T<span style=color:#f92672>&amp;&amp;</span> v);
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>size_t N<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>failure<span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>string<span style=color:#f92672>&gt;</span> err(<span style=color:#66d9ef>const</span> <span style=color:#66d9ef>char</span> (<span style=color:#f92672>&amp;</span>literal)[N]);
</span></span><span style=display:flex><span>}
</span></span></code></pre></div><h2 id=member-types-2>Member Types
<a class=anchor href=#member-types-2>#</a></h2><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span></code></pre></div><p>The type of the failure value.</p><h2 id=member-functions-1>Member Functions
<a class=anchor href=#member-functions-1>#</a></h2><h3 id=constructor-1>Constructor
<a class=anchor href=#constructor-1>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>explicit</span> <span style=color:#a6e22e>failure</span>(value_type v);
</span></span></code></pre></div><p>Constructs with a <code>value_type</code> argument.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>explicit</span> failure(U<span style=color:#f92672>&amp;&amp;</span> v);
</span></span></code></pre></div><p>Constructs with another type that can be converted to <code>value_type</code>.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>explicit</span> failure(failure<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> v);
</span></span></code></pre></div><p>Constructs with another <code>failure</code> type that can be converted to <code>value_type</code>.</p><h3 id=get-2><code>get()</code>
<a class=anchor href=#get-2>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Accesses the stored value.</p><h2 id=non-member-functions-1>Non-Member Functions
<a class=anchor href=#non-member-functions-1>#</a></h2><h3 id=errt><code>err(T)</code>
<a class=anchor href=#errt>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>failure<span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> std<span style=color:#f92672>::</span>decay<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;::</span>type<span style=color:#f92672>&gt;</span> err(T<span style=color:#f92672>&amp;&amp;</span> v);
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>size_t N<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>failure<span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>string<span style=color:#f92672>&gt;</span> err(<span style=color:#66d9ef>const</span> <span style=color:#66d9ef>char</span> (<span style=color:#f92672>&amp;</span>literal)[N]);
</span></span></code></pre></div><p>Constructs and returns a <code>failure</code> type from a failure value.</p><p>Converts a string literal into <code>std::string</code>.</p><h1 id=failurereference_wrappert><code>failure&lt;reference_wrapper&lt;T>></code>
<a class=anchor href=#failurereference_wrappert>#</a></h1><p>Specialization of <code>failure</code> for when the failure value is a reference.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>namespace</span> toml
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>failure</span><span style=color:#f92672>&lt;</span>std<span style=color:#f92672>::</span>reference_wrapper<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;&gt;</span>
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> <span style=color:#a6e22e>failure</span>(std<span style=color:#f92672>::</span>reference_wrapper<span style=color:#f92672>&lt;</span>value_type<span style=color:#f92672>&gt;</span> v) <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span> {<span style=color:#66d9ef>return</span> value.get();}
</span></span><span style=display:flex><span> value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span> {<span style=color:#66d9ef>return</span> value.get();}
</span></span><span style=display:flex><span>};
</span></span><span style=display:flex><span>}
</span></span></code></pre></div><h2 id=member-types-3>Member Types
<a class=anchor href=#member-types-3>#</a></h2><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> T;
</span></span></code></pre></div><p>The type of the failure value. It is <code>T</code> from <code>std::reference_wrapper&lt;T></code>, not the reference itself.</p><h3 id=get-3><code>get()</code>
<a class=anchor href=#get-3>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>value_type<span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> get() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Accesses the stored value.</p><h1 id=result>result
<a class=anchor href=#result>#</a></h1><p>A type that holds either a success value or a failure value.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>namespace</span> toml
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> T, <span style=color:#66d9ef>typename</span> E<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>result</span>
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> success_type <span style=color:#f92672>=</span> success<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;</span>;
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> failure_type <span style=color:#f92672>=</span> failure<span style=color:#f92672>&lt;</span>E<span style=color:#f92672>&gt;</span>;
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> value_type <span style=color:#f92672>=</span> <span style=color:#66d9ef>typename</span> success_type<span style=color:#f92672>::</span>value_type;
</span></span><span style=display:flex><span> <span style=color:#66d9ef>using</span> error_type <span style=color:#f92672>=</span> <span style=color:#66d9ef>typename</span> failure_type<span style=color:#f92672>::</span>value_type;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> result(success_type s);
</span></span><span style=display:flex><span> result(failure_type f);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> result(success<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> s);
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> result(failure<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> f);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(success_type s);
</span></span><span style=display:flex><span> result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(failure_type f);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(success<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> s);
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(failure<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> f);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#f92672>~</span>result() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> result(<span style=color:#66d9ef>const</span> result<span style=color:#f92672>&amp;</span> other);
</span></span><span style=display:flex><span> result(result<span style=color:#f92672>&amp;&amp;</span> other);
</span></span><span style=display:flex><span> result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(<span style=color:#66d9ef>const</span> result<span style=color:#f92672>&amp;</span> other);
</span></span><span style=display:flex><span> result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(result<span style=color:#f92672>&amp;&amp;</span> other);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U, <span style=color:#66d9ef>typename</span> F<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> result(result<span style=color:#f92672>&lt;</span>U, F<span style=color:#f92672>&gt;</span> other);
</span></span><span style=display:flex><span> <span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U, <span style=color:#66d9ef>typename</span> F<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span> result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(result<span style=color:#f92672>&lt;</span>U, F<span style=color:#f92672>&gt;</span> other);
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>bool</span> <span style=color:#a6e22e>is_ok</span>() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span> <span style=color:#66d9ef>bool</span> <span style=color:#a6e22e>is_err</span>() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> <span style=color:#66d9ef>operator</span> <span style=color:#a6e22e>bool</span>() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> value_type<span style=color:#f92672>&amp;</span> unwrap(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current());
</span></span><span style=display:flex><span> value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> unwrap(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current()) <span style=color:#66d9ef>const</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> value_type<span style=color:#f92672>&amp;</span> unwrap_or(value_type<span style=color:#f92672>&amp;</span> opt) <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span> value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> unwrap_or(value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> opt) <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> error_type<span style=color:#f92672>&amp;</span> unwrap_err(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current());
</span></span><span style=display:flex><span> error_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> unwrap_err(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current()) <span style=color:#66d9ef>const</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> value_type<span style=color:#f92672>&amp;</span> as_ok() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span> value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> as_ok() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span> error_type<span style=color:#f92672>&amp;</span> as_err() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span> error_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> as_err() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>};
</span></span><span style=display:flex><span>}
</span></span></code></pre></div><h2 id=member-types-4>Member Types
<a class=anchor href=#member-types-4>#</a></h2><h3 id=success_type><code>success_type</code>
<a class=anchor href=#success_type>#</a></h3><p><code>success&lt;T></code>.</p><h3 id=failure_type><code>failure_type</code>
<a class=anchor href=#failure_type>#</a></h3><p><code>failure&lt;E></code>.</p><h3 id=value_type><code>value_type</code>
<a class=anchor href=#value_type>#</a></h3><p>The type <code>T</code> of the success value, alias for <code>success_type::value_type</code>.</p><p>If <code>T</code> is <code>std::reference_wrapper&lt;U></code>, then it is <code>U</code>.</p><h3 id=error_type><code>error_type</code>
<a class=anchor href=#error_type>#</a></h3><p>The type <code>E</code> of the failure value, alias for <code>failure_type::value_type</code>.</p><p>If <code>E</code> is <code>std::reference_wrapper&lt;F></code>, then it is <code>F</code>.</p><h2 id=member-functions-2>Member Functions
<a class=anchor href=#member-functions-2>#</a></h2><h3 id=constructor-2>Constructor
<a class=anchor href=#constructor-2>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>result() <span style=color:#f92672>=</span> <span style=color:#66d9ef>delete</span>;
</span></span></code></pre></div><p>Cannot construct <code>result</code> type by default. Needs to be given either a success or failure type.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>result(success_type s);
</span></span><span style=display:flex><span>result(failure_type f);
</span></span></code></pre></div><p>Constructs with a <code>success_type</code> or <code>failure_type</code>.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>result(success<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> s);
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>result(failure<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> f);
</span></span></code></pre></div><p>Constructs with a <code>success&lt;U></code> or <code>failure&lt;U></code> that is convertible to <code>value_type</code> or <code>error_type</code>.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U, <span style=color:#66d9ef>typename</span> F<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>result(result<span style=color:#f92672>&lt;</span>U, F<span style=color:#f92672>&gt;</span> other);
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U, <span style=color:#66d9ef>typename</span> F<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(result<span style=color:#f92672>&lt;</span>U, F<span style=color:#f92672>&gt;</span> other);
</span></span></code></pre></div><p>Constructs from or assigns to another <code>result</code> with convertible <code>success</code> or <code>failure</code> types.</p><h3 id=copy-and-move-constructors>Copy and Move Constructors
<a class=anchor href=#copy-and-move-constructors>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>result(<span style=color:#66d9ef>const</span> result<span style=color:#f92672>&amp;</span> other);
</span></span><span style=display:flex><span>result(result<span style=color:#f92672>&amp;&amp;</span> other);
</span></span></code></pre></div><p>Can be copy or move constructed.</p><h3 id=operator><code>operator=</code>
<a class=anchor href=#operator>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(<span style=color:#66d9ef>const</span> result<span style=color:#f92672>&amp;</span> other);
</span></span><span style=display:flex><span>result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(result<span style=color:#f92672>&amp;&amp;</span> other);
</span></span></code></pre></div><p>Can be copy or move assigned.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(success<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> s);
</span></span><span style=display:flex><span><span style=color:#66d9ef>template</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>typename</span> U<span style=color:#f92672>&gt;</span>
</span></span><span style=display:flex><span>result<span style=color:#f92672>&amp;</span> <span style=color:#66d9ef>operator</span><span style=color:#f92672>=</span>(failure<span style=color:#f92672>&lt;</span>U<span style=color:#f92672>&gt;</span> f);
</span></span></code></pre></div><p>Can be assigned from convertible <code>success</code> or <code>failure</code> types.</p><h3 id=is_ok><code>is_ok()</code>
<a class=anchor href=#is_ok>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>bool</span> <span style=color:#a6e22e>is_ok</span>() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Returns <code>true</code> if it holds a success value, <code>false</code> otherwise.</p><h3 id=is_err><code>is_err()</code>
<a class=anchor href=#is_err>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>bool</span> <span style=color:#a6e22e>is_err</span>() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Returns <code>true</code> if it holds a failure value, <code>false</code> otherwise.</p><h3 id=operator-bool><code>operator bool()</code>
<a class=anchor href=#operator-bool>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>explicit</span> <span style=color:#66d9ef>operator</span> <span style=color:#a6e22e>bool</span>() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Returns <code>true</code> if it holds a success value, <code>false</code> otherwise.</p><h3 id=unwrap><code>unwrap()</code>
<a class=anchor href=#unwrap>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>value_type<span style=color:#f92672>&amp;</span> unwrap(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current());
</span></span><span style=display:flex><span>value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> unwrap(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current()) <span style=color:#66d9ef>const</span>;
</span></span></code></pre></div><p>Returns the stored success value.</p><p>Throws <code>toml::bad_result_access</code> if it holds a failure value.</p><p>If <code>std::source_location</code> or equivalent compiler extension is available, the file name and line number where <code>unwrap()</code> occurred are included in the <code>what()</code> string.</p><h3 id=unwrap_or><code>unwrap_or()</code>
<a class=anchor href=#unwrap_or>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>value_type<span style=color:#f92672>&amp;</span> unwrap_or(value_type<span style=color:#f92672>&amp;</span> opt) <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> unwrap_or(value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> opt) <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Returns the stored success value if present, otherwise returns the provided default value.</p><h3 id=unwrap_err><code>unwrap_err()</code>
<a class=anchor href=#unwrap_err>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>error_type<span style=color:#f92672>&amp;</span> unwrap_err(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current());
</span></span><span style=display:flex><span>error_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> unwrap_err(cxx<span style=color:#f92672>::</span>source_location loc <span style=color:#f92672>=</span> cxx<span style=color:#f92672>::</span>source_location<span style=color:#f92672>::</span>current()) <span style=color:#66d9ef>const</span>;
</span></span></code></pre></div><p>Returns the stored failure value.</p><p>Throws <code>toml::bad_result_access</code> if it holds a success value.</p><p>If <code>std::source_location</code> or equivalent compiler extension is available, the file name and line number where <code>unwrap_err()</code> occurred are included in the <code>what()</code> string.</p><h3 id=as_ok><code>as_ok()</code>
<a class=anchor href=#as_ok>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>value_type<span style=color:#f92672>&amp;</span> as_ok() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>value_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> as_ok() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Returns the success value without checking.</p><p>Behavior is undefined if it holds a failure value.</p><h3 id=as_err><code>as_err()</code>
<a class=anchor href=#as_err>#</a></h3><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span>error_type<span style=color:#f92672>&amp;</span> as_err() <span style=color:#66d9ef>noexcept</span>;
</span></span><span style=display:flex><span>error_type <span style=color:#66d9ef>const</span><span style=color:#f92672>&amp;</span> as_err() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span>;
</span></span></code></pre></div><p>Returns the failure value without checking.</p><p>Behavior is undefined if it holds a success value.</p><h1 id=bad_result_access>bad_result_access
<a class=anchor href=#bad_result_access>#</a></h1><p>An exception thrown when <code>unwrap</code> or <code>unwrap_err</code> fails in a <code>result</code>.</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-cpp data-lang=cpp><span style=display:flex><span><span style=color:#66d9ef>namespace</span> toml
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>bad_result_access</span> <span style=color:#f92672>:</span> <span style=color:#66d9ef>public</span> <span style=color:#f92672>::</span>toml<span style=color:#f92672>::</span>exception
</span></span><span style=display:flex><span>{
</span></span><span style=display:flex><span> <span style=color:#66d9ef>public</span><span style=color:#f92672>:</span>
</span></span><span style=display:flex><span> <span style=color:#66d9ef>explicit</span> bad_result_access(<span style=color:#66d9ef>const</span> std<span style=color:#f92672>::</span>string<span style=color:#f92672>&amp;</span> what_arg);
</span></span><span style=display:flex><span> <span style=color:#66d9ef>virtual</span> <span style=color:#f92672>~</span>bad_result_access() <span style=color:#66d9ef>noexcept</span> <span style=color:#66d9ef>override</span> <span style=color:#f92672>=</span> <span style=color:#66d9ef>default</span>;
</span></span><span style=display:flex><span> <span style=color:#66d9ef>virtual</span> <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>char</span><span style=color:#f92672>*</span> <span style=color:#a6e22e>what</span>() <span style=color:#66d9ef>const</span> <span style=color:#66d9ef>noexcept</span> <span style=color:#66d9ef>override</span>;
</span></span><span style=display:flex><span> <span style=color:#66d9ef>protected</span><span style=color:#f92672>:</span>
</span></span><span style=display:flex><span> std<span style=color:#f92672>::</span>string what_;
</span></span><span style=display:flex><span>};
</span></span><span style=display:flex><span>}
</span></span></code></pre></div></article><footer class=book-footer><div class="flex flex-wrap justify-between"></div><script>(function(){function e(e){const t=window.getSelection(),n=document.createRange();n.selectNodeContents(e),t.removeAllRanges(),t.addRange(n)}document.querySelectorAll("pre code").forEach(t=>{t.addEventListener("click",function(){if(window.getSelection().toString())return;e(t.parentElement),navigator.clipboard&&navigator.clipboard.writeText(t.parentElement.textContent)})})})()</script></footer><label for=menu-control class="hidden book-menu-overlay"></label></div><aside class=book-toc><div class=book-toc-content><nav id=TableOfContents><ul><li><a href=#resulthpp>result.hpp</a></li><li><a href=#success>success</a><ul><li><a href=#member-types>Member Types</a></li><li><a href=#member-functions>Member Functions</a><ul><li><a href=#constructor>Constructor</a></li><li><a href=#get><code>get()</code></a></li></ul></li><li><a href=#non-member-functions>Non-Member Functions</a><ul><li><a href=#okt><code>ok(T)</code></a></li></ul></li></ul></li><li><a href=#successreference_wrappert><code>success&lt;reference_wrapper&lt;T>></code></a><ul><li><a href=#member-types-1>Member Types</a><ul><li><a href=#get-1><code>get()</code></a></li></ul></li></ul></li><li><a href=#failure>failure</a><ul><li><a href=#member-types-2>Member Types</a></li><li><a href=#member-functions-1>Member Functions</a><ul><li><a href=#constructor-1>Constructor</a></li><li><a href=#get-2><code>get()</code></a></li></ul></li><li><a href=#non-member-functions-1>Non-Member Functions</a><ul><li><a href=#errt><code>err(T)</code></a></li></ul></li></ul></li><li><a href=#failurereference_wrappert><code>failure&lt;reference_wrapper&lt;T>></code></a><ul><li><a href=#member-types-3>Member Types</a><ul><li><a href=#get-3><code>get()</code></a></li></ul></li></ul></li><li><a href=#result>result</a><ul><li><a href=#member-types-4>Member Types</a><ul><li><a href=#success_type><code>success_type</code></a></li><li><a href=#failure_type><code>failure_type</code></a></li><li><a href=#value_type><code>value_type</code></a></li><li><a href=#error_type><code>error_type</code></a></li></ul></li><li><a href=#member-functions-2>Member Functions</a><ul><li><a href=#constructor-2>Constructor</a></li><li><a href=#copy-and-move-constructors>Copy and Move Constructors</a></li><li><a href=#operator><code>operator=</code></a></li><li><a href=#is_ok><code>is_ok()</code></a></li><li><a href=#is_err><code>is_err()</code></a></li><li><a href=#operator-bool><code>operator bool()</code></a></li><li><a href=#unwrap><code>unwrap()</code></a></li><li><a href=#unwrap_or><code>unwrap_or()</code></a></li><li><a href=#unwrap_err><code>unwrap_err()</code></a></li><li><a href=#as_ok><code>as_ok()</code></a></li><li><a href=#as_err><code>as_err()</code></a></li></ul></li></ul></li><li><a href=#bad_result_access>bad_result_access</a></li></ul></nav></div></aside></main></body></html>
Reference in New Issue View Git Blame Copy Permalink