coffee/continuable
1
0
Fork 0
mirror of https://github.com/Naios/continuable.git synced 2025-12-06 08:46:44 +08:00
Code Issues Packages Projects Releases Wiki Activity
continuable/classcti_1_1continuable__base.html
Naios c349bf0e5b Publish
2018-03-17 13:27:07 +01:00

842 lines
81 KiB
HTML
Raw Permalink Blame History

<!DOCTYPE html>
<html lang="en">
<head>
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-115514125-1"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());
gtag('config', 'UA-115514125-1');
</script>
<meta charset="UTF-8" />
<title>cti::continuable_base class | Continuable</title>
<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,400i,600,600i%7CSource+Code+Pro:400,400i,600" />
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"/>
<link rel="stylesheet" href="m-dark+doxygen.compiled.css" />
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"/>
<link rel="stylesheet" href="base.css" />
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"/>
<link rel="stylesheet" href="terminal.css" />
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"/>
<link rel="stylesheet" href="atom-one-dark.css" />
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta name="theme-color" content="#23373B" />
</head>
<body>
<header><nav id="navigation">
<div class="m-container">
<div class="m-row">
<a href="index.html" id="m-navbar-brand" class="m-col-t-8 m-col-m-none m-left-m">Continuable <span class="m-thin">3.0.0</span></a>
<div class="m-col-t-4 m-hide-m m-text-right m-nopadr">
<a href="#search" class="m-dox-search-icon" title="Search" onclick="return showSearch()"><svg viewBox="0 0 16 16">
<path d="m6 0c-3.3144 0-6 2.6856-6 6 0 3.3144 2.6856 6 6 6 1.4858 0 2.8463-0.54083 3.8945-1.4355-0.0164 0.33797 0.14734 0.75854 0.5 1.1504l3.2227 3.7891c0.55185 0.6139 1.4517 0.66544 2.002 0.11524 0.55022-0.55022 0.49866-1.4501-0.11524-2.002l-3.7891-3.2246c-0.39184-0.35266-0.81242-0.51469-1.1504-0.5 0.89472-1.0482 1.4355-2.4088 1.4355-3.8945 0-3.3128-2.6856-5.998-6-5.998zm0 1.5625a4.4375 4.4375 0 0 1 4.4375 4.4375 4.4375 4.4375 0 0 1-4.4375 4.4375 4.4375 4.4375 0 0 1-4.4375-4.4375 4.4375 4.4375 0 0 1 4.4375-4.4375z"/>
</svg></a>
<a id="m-navbar-show" href="#navigation" title="Show navigation"></a>
<a id="m-navbar-hide" href="#" title="Hide navigation"></a>
</div>
<div id="m-navbar-collapse" class="m-col-t-12 m-show-m m-col-m-none m-right-m">
<div class="m-row">
<ol class="m-col-t-6 m-col-m-none">
<li>
<a href="tutorial.html">Tutorial</a>
<ol>
<li><a href="tutorial-creating-continuables.html">Creating continuables</a></li>
<li><a href="tutorial-chaining-continuables.html">Chaining continuables</a></li>
<li><a href="tutorial-connecting-continuables.html">Connecting continuables</a></li>
<li><a href="tutorial-transforming-continuables.html">Transforming continuables</a></li>
<li><a href="tutorial-awaiting-continuables.html">Awaiting continuables</a></li>
<li><a href="tutorial-promisify-continuables.html">Promisify functions</a></li>
</ol>
</li>
<li>
<a href="pages.html">Pages</a>
<ol>
<li><a href="installation.html">Installation</a></li>
<li><a href="tutorial.html">Tutorial</a></li>
<li><a href="configuration.html">Configuration</a></li>
<li><a href="changelog.html">Changelog</a></li>
</ol>
</li>
<li>
<a href="modules.html">Modules</a>
<ol>
<li><a href="group___base.html">Base</a></li>
<li><a href="group___connections.html">Connections</a></li>
<li><a href="group___promisify.html">Promisify</a></li>
<li><a href="group___testing.html">Testing</a></li>
<li><a href="group___types.html">Types</a></li>
<li><a href="group___transforms.html">Transforms</a></li>
<li><a href="group___traversal.html">Traversal</a></li>
</ol>
</li>
</ol>
<ol class="m-col-t-6 m-col-m-none" start="4">
<li>
<a href="namespacecti.html">cti</a>
<ol>
<li><a href="namespacecti_1_1transforms.html">cti::transforms</a></li>
<li><a href="classcti_1_1continuable__base.html" id="m-navbar-current">cti::continuable_base</a></li>
<li><a href="classcti_1_1promise__base.html">cti::promise_base</a></li>
</ol>
</li>
<li class="m-show-m"><a href="#search" class="m-dox-search-icon" title="Search" onclick="return showSearch()"><svg viewBox="0 0 16 16">
<path d="m6 0c-3.3144 0-6 2.6856-6 6 0 3.3144 2.6856 6 6 6 1.4858 0 2.8463-0.54083 3.8945-1.4355-0.0164 0.33797 0.14734 0.75854 0.5 1.1504l3.2227 3.7891c0.55185 0.6139 1.4517 0.66544 2.002 0.11524 0.55022-0.55022 0.49866-1.4501-0.11524-2.002l-3.7891-3.2246c-0.39184-0.35266-0.81242-0.51469-1.1504-0.5 0.89472-1.0482 1.4355-2.4088 1.4355-3.8945 0-3.3128-2.6856-5.998-6-5.998zm0 1.5625a4.4375 4.4375 0 0 1 4.4375 4.4375 4.4375 4.4375 0 0 1-4.4375 4.4375 4.4375 4.4375 0 0 1-4.4375-4.4375 4.4375 4.4375 0 0 1 4.4375-4.4375z"/>
</svg> Search</a></li>
</ol>
<ol class="m-col-t-6 m-col-m-none">
<li>
<a href="https://github.com/Naios/continuable" aria-label="View source on Github"><i class="fa fa-github"></i> Code</a>
</li>
</ol>
</div>
</div>
</div>
</div>
</nav></header>
<main><article>
<div class="m-container m-container-inflatable">
<div class="m-row">
<div class="m-col-l-10 m-push-l-1">
<h1>
<div class="m-dox-template">template&lt;typename Data, typename Annotation&gt;</div>
<span class="m-breadcrumb"><a href="namespacecti.html">cti</a>::</span>continuable_base <span class="m-thin">class</span>
</h1>
<p>The main class of the continuable library, it provides the functionality for chaining callbacks and continuations together to a unified hierarchy.</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%">Data</td>
<td>The internal data which is used to store the current continuation and intermediate lazy connection result.</td>
</tr>
<tr>
<td>Annotation</td>
<td>The internal data used to store the current signature hint or strategy used for combining lazy connections.</td>
</tr>
</tbody>
</table>
<div class="m-block m-default">
<h3>Contents</h3>
<ul>
<li>
Reference
<ul>
<li><a href="#typeless-methods">Constructors, destructors, conversion operators</a></li>
<li><a href="#pub-methods">Public functions</a></li>
</ul>
</li>
</ul>
</div>
<p>The most important method is the <a href="classcti_1_1continuable__base.html#adf02030d7211ffc4610f3bcb13d2a149" class="m-dox">cti::<wbr />continuable_base::<wbr />then()</a> method, which allows to attach a callback to the continuable.</p><p>Use the continuable types defined in <code><a href="continuable_8hpp.html" class="m-dox">continuable/<wbr />continuable.hpp</a></code>, in order to use this class.</p><aside class="m-note m-info"><h4>Note</h4><p>Nearly all methods of the <a href="classcti_1_1continuable__base.html" class="m-dox">cti::<wbr />continuable_base</a> are required to be called as r-value. This is required because the continuable carries variables which are consumed when the object is transformed as part of a method call.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>The <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects aren&#x27;t intended to be stored. If you want to store a continuble_base you should always call the <a href="classcti_1_1continuable__base.html#a3c8d7fefc2f65fcd474c99d821809d24" class="m-dox">continuable_base::<wbr />freeze</a> method for disabling the invocation on destruction.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
<section id="typeless-methods">
<h2><a href="#typeless-methods">Constructors, destructors, conversion operators</a></h3>
<dl class="m-dox">
<dt>
<span class="m-dox-wrap-bumper"><a href="#aaa60b403ed3408968d8ab37ef719e014" class="m-dox-self" name="aaa60b403ed3408968d8ab37ef719e014">continuable_base</a>(</span><span class="m-dox-wrap">Data data) <span class="m-label m-flat m-info">explicit</span> </span>
</dt>
<dd>Constructor accepting the data object while erasing the annotation.</dd>
<dt>
<div class="m-dox-template">template&lt;typename OData, std::enable_if_t&lt;std::is_convertible&lt;std::decay_t&lt;OData&gt;, Data&gt;::value&gt;* = nullptr&gt;</div>
<span class="m-dox-wrap-bumper"><a href="#a413696725b0ccbb504be13920f7ab127" class="m-dox-self" name="a413696725b0ccbb504be13920f7ab127">continuable_base</a>(</span><span class="m-dox-wrap">OData&amp;&amp; data)</span>
</dt>
<dd>Constructor accepting any object convertible to the data object, while erasing the annotation.</dd>
<dt>
<div class="m-dox-template">template&lt;typename OData, typename OAnnotation&gt;</div>
<span class="m-dox-wrap-bumper"><a href="#a8768c76d5d9bad19d820d9752faa337e" class="m-dox">continuable_base</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; other)</span>
</dt>
<dd>Constructor taking the data of other <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects while erasing the hint.</dd>
<dt>
<span class="m-dox-wrap-bumper"><a href="#ad52b8e48a62fa038d06faaca58295067" class="m-dox">~continuable_base</a>(</span><span class="m-dox-wrap">)</span>
</dt>
<dd>The destructor automatically invokes the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> if it wasn&#x27;t consumed yet.</dd>
</dl>
</section>
<section id="pub-methods">
<h2><a href="#pub-methods">Public functions</a></h3>
<dl class="m-dox">
<dt>
<div class="m-dox-template">template&lt;typename T, typename E = detail::types::this_thread_executor_tag&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#adf02030d7211ffc4610f3bcb13d2a149" class="m-dox">then</a>(</span><span class="m-dox-wrap">T&amp;&amp; callback,
E&amp;&amp; executor = detail::types::this_thread_executor_tag{}) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Main method of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> to chain the current continuation with a new callback.</dd>
<dt>
<div class="m-dox-template">template&lt;typename OData, typename OAnnotation&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#a302341be87c7991b4409b743d0d14a9d" class="m-dox">then</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; continuation) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Additional overload of the <a href="classcti_1_1continuable__base.html#adf02030d7211ffc4610f3bcb13d2a149" class="m-dox">continuable_base::<wbr />then()</a> method which is accepting a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> itself.</dd>
<dt>
<div class="m-dox-template">template&lt;typename T, typename E = detail::types::this_thread_executor_tag&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#a7001122101ed32f729e39c53d6cb9c7f" class="m-dox">fail</a>(</span><span class="m-dox-wrap">T&amp;&amp; callback,
E&amp;&amp; executor = detail::types::this_thread_executor_tag{}) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Main method of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> to catch exceptions and error codes in case the asynchronous control flow failed and was resolved through an error code or exception.</dd>
<dt>
<div class="m-dox-template">template&lt;typename OData, typename OAnnotation&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ac9da66a917e3d6901497d62eb67eaad0" class="m-dox">fail</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; continuation) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Additional overload of the <a href="classcti_1_1continuable__base.html#a7001122101ed32f729e39c53d6cb9c7f" class="m-dox">continuable_base::<wbr />fail()</a> method which is accepting a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> itself.</dd>
<dt>
<div class="m-dox-template">template&lt;typename T, typename E = detail::types::this_thread_executor_tag&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ad4960d0794abb800f1dfd9a668900149" class="m-dox">next</a>(</span><span class="m-dox-wrap">T&amp;&amp; callback,
E&amp;&amp; executor = detail::types::this_thread_executor_tag{}) &amp;&amp; -&gt; auto</span>
</dt>
<dd>A method which allows to use an overloaded callable for the error as well as the valid result path.</dd>
<dt>
<div class="m-dox-template">template&lt;typename T&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#abcf4cf105aa17826bcc3c2278f6ea1b5" class="m-dox">apply</a>(</span><span class="m-dox-wrap">T&amp;&amp; transform) &amp;&amp; -&gt; auto</span>
</dt>
<dd>A method which allows to apply this continuable to the given callable.</dd>
<dt>
<div class="m-dox-template">template&lt;typename T&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ae2d35537ea76f421ba4aed86dd849f98" class="m-dox">operator|</a>(</span><span class="m-dox-wrap">T&amp;&amp; right) &amp;&amp; -&gt; auto</span>
</dt>
<dd>The pipe operator | is an alias for the continuable::then method.</dd>
<dt>
<div class="m-dox-template">template&lt;typename T&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#a80027c1b07600076960ebcb87fd064c1" class="m-dox">operator|</a>(</span><span class="m-dox-wrap">detail::types::transform&lt;T&gt; transform) &amp;&amp; -&gt; auto</span>
</dt>
<dd>The pipe operator | is an alias for the continuable::apply method.</dd>
<dt>
<div class="m-dox-template">template&lt;typename OData, typename OAnnotation&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#a43ad4bfb19234a7856972d97337498db" class="m-dox">operator&amp;&amp;</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; right) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Invokes both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects parallel and calls the callback with the result of both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects.</dd>
<dt>
<div class="m-dox-template">template&lt;typename OData, typename OAnnotation&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ada74584fb95bf00a50d05072e933c144" class="m-dox">operator||</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; right) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Invokes both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects parallel and calls the callback once with the first result available.</dd>
<dt>
<div class="m-dox-template">template&lt;typename OData, typename OAnnotation&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#abaaaf8a35827456fead299851268760e" class="m-dox">operator&gt;&gt;</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; right) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Invokes both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects sequential and calls the callback with the result of both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects.</dd>
<dt>
<span class="m-dox-wrap-bumper">void <a href="#a26ca692e597ebd8beff7d58d8bf584f4" class="m-dox">done</a>(</span><span class="m-dox-wrap">) &amp;&amp;</span>
</dt>
<dd>Invokes the continuation chain manually even before the <a href="classcti_1_1continuable__base.html" class="m-dox">cti::<wbr />continuable_base</a> is destructed. This will release the object.</dd>
<dt>
<span class="m-dox-wrap-bumper">auto <a href="#a1bd6ce7c083af5faf4b241ada8d6f5f7" class="m-dox">is_frozen</a>(</span><span class="m-dox-wrap">) const -&gt; bool <span class="m-label m-flat m-success">noexcept</span></span>
</dt>
<dd>Predicate to check whether the <a href="classcti_1_1continuable__base.html" class="m-dox">cti::<wbr />continuable_base</a> is frozen or not.</dd>
<dt>
<span class="m-dox-wrap-bumper">auto <a href="#a3c8d7fefc2f65fcd474c99d821809d24" class="m-dox">freeze</a>(</span><span class="m-dox-wrap">bool enabled = true) &amp;noexcept -&gt; <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&amp;</span>
</dt>
<dd>Prevents the automatic invocation of the continuation chain which happens on destruction of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>. You may still invoke the chain through the <a href="classcti_1_1continuable__base.html#a26ca692e597ebd8beff7d58d8bf584f4" class="m-dox">continuable_base::<wbr />done</a> method.</dd>
<dt>
<span class="m-dox-wrap-bumper">auto <a href="#a193e56e793fb40f56d6c6a942f605972" class="m-dox">freeze</a>(</span><span class="m-dox-wrap">bool enabled = true) &amp;&amp;noexcept -&gt; <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&amp;&amp;</span>
</dt>
<dd>Prevents the automatic invocation of the continuation chain which happens on destruction of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>. You may still invoke the chain through the <a href="classcti_1_1continuable__base.html#a26ca692e597ebd8beff7d58d8bf584f4" class="m-dox">continuable_base::<wbr />done</a> method.</dd>
<dt>
<span class="m-dox-wrap-bumper">auto <a href="#ac79b103d5c000a3a3d1b98d8adcf58e8" class="m-dox">operator co_await</a>(</span><span class="m-dox-wrap">) &amp;&amp; -&gt; auto</span>
</dt>
<dd>Implements the operator for awaiting on continuables using <code>co_await</code>.</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-dox-details" id="a8768c76d5d9bad19d820d9752faa337e"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename OData, typename OAnnotation&gt;
</div>
<span class="m-dox-wrap-bumper"> cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a8768c76d5d9bad19d820d9752faa337e" class="m-dox-self">continuable_base</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; other)</span></span>
</h3>
<p>Constructor taking the data of other <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects while erasing the hint.</p>
<p>This constructor makes it possible to replace the internal data object of the continuable by any object which is useful for type-erasure.</p>
</div></section>
<section class="m-dox-details" id="ad52b8e48a62fa038d06faaca58295067"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
</div>
<span class="m-dox-wrap-bumper"> cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ad52b8e48a62fa038d06faaca58295067" class="m-dox-self">~continuable_base</a>(</span><span class="m-dox-wrap">)</span></span>
</h3>
<p>The destructor automatically invokes the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> if it wasn&#x27;t consumed yet.</p>
<p>In order to invoke the continuable early you may call the <a href="classcti_1_1continuable__base.html#a26ca692e597ebd8beff7d58d8bf584f4" class="m-dox">continuable_base::<wbr />done()</a> method.</p><p>The <a href="classcti_1_1continuable__base.html#a3c8d7fefc2f65fcd474c99d821809d24" class="m-dox">continuable_base::<wbr />freeze</a> method disables the automatic invocation on destruction without invalidating the object.</p><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="adf02030d7211ffc4610f3bcb13d2a149"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename T, typename E = detail::types::this_thread_executor_tag&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#adf02030d7211ffc4610f3bcb13d2a149" class="m-dox-self">then</a>(</span><span class="m-dox-wrap">T&amp;&amp; callback,
E&amp;&amp; executor = detail::types::this_thread_executor_tag{}) &amp;&amp;</span></span>
</h3>
<p>Main method of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> to chain the current continuation with a new callback.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">callback</td>
<td><p>The callback which is used to process the current asynchronous result on arrival. The callback is required to accept the current result at least partially (or nothing of the result).</p><pre class="m-code"><span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span> <span class="o">&amp;&amp;</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">atom</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// We use the whole result</span>
<span class="p">});</span>
<span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span> <span class="o">&amp;&amp;</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// We only use the result partially</span>
<span class="p">});</span>
<span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span> <span class="o">&amp;&amp;</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([]</span> <span class="p">{</span>
<span class="c1">// We discard the result</span>
<span class="p">});</span></pre></td>
</tr>
<tr>
<td>executor</td>
<td><p>The optional executor which is used to dispatch the callback. The executor needs to accept callable objects callable through an <code>operator()</code> through its operator() itself. The executor can be move-only, but it&#x27;s not required to. The default executor which is used when omitting the argument dispatches the callback on the current executing thread. Consider the example shown below:</p><pre class="m-code"><span class="k">auto</span> <span class="n">executor</span> <span class="o">=</span> <span class="p">[](</span><span class="k">auto</span><span class="o">&amp;&amp;</span> <span class="n">work</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// Dispatch the work here or forward it to an executor of</span>
<span class="c1">// your choice.</span>
<span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="k">decltype</span><span class="p">(</span><span class="n">work</span><span class="p">)</span><span class="o">&gt;</span><span class="p">(</span><span class="n">work</span><span class="p">)();</span>
<span class="p">};</span>
<span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// Do something...</span>
<span class="p">},</span> <span class="n">executor</span><span class="p">);</span></pre></td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td><p>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with an asynchronous return type depending on the return value of the callback:</p><table class="m-table"><thead><tr><th>Callback returns</th><th>Resulting type</th></tr></thead><tbody><tr><td><code>void</code></td><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;&gt;</code></td></tr><tr><td><code>Arg</code></td><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;Arg&gt;</code></td></tr><tr><td><code>std::pair&lt;First, Second&gt;</code></td><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;First, Second&gt;</code></td></tr><tr><td><code>std::tuple&lt;Args...&gt;</code></td><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;Args...&gt;</code></td></tr><tr><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;Arg...&gt;</code></td><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;Args...&gt;</code></td></tr></tbody></table><p>Which means the result type of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> is equal to the plain types the callback returns (<code>std::tuple</code> and <code>std::pair</code> arguments are unwrapped). A single <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> as argument is resolved and the result type is equal to the resolved <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>. Consider the following examples:</p><pre class="m-code"><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span><span class="p">;</span> <span class="p">})</span>
<span class="p">.</span><span class="n">then</span><span class="p">([]</span> <span class="p">{</span> <span class="p">});</span> <span class="c1">// &lt;void&gt;</span>
<span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">})</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="kt">int</span> <span class="n">a</span><span class="p">)</span> <span class="p">{</span> <span class="p">});</span> <span class="c1">// &lt;int&gt;</span>
<span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">make_pair</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">);</span> <span class="p">})</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">int</span> <span class="n">b</span><span class="p">)</span> <span class="p">{</span> <span class="p">});</span> <span class="c1">// &lt;int, int&gt;</span>
<span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">);</span> <span class="p">})</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">int</span> <span class="n">b</span><span class="p">,</span> <span class="kt">int</span> <span class="n">c</span><span class="p">)</span> <span class="p">{</span> <span class="p">});</span> <span class="c1">// &lt;int, int, int&gt;</span>
<span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">);</span> <span class="p">})</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">atom</span><span class="p">)</span> <span class="p">{</span> <span class="p">});</span> <span class="c1">// &lt;std::string&gt;</span></pre></td>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a302341be87c7991b4409b743d0d14a9d"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename OData, typename OAnnotation&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a302341be87c7991b4409b743d0d14a9d" class="m-dox-self">then</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; continuation) &amp;&amp;</span></span>
</h3>
<p>Additional overload of the <a href="classcti_1_1continuable__base.html#adf02030d7211ffc4610f3bcb13d2a149" class="m-dox">continuable_base::<wbr />then()</a> method which is accepting a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> itself.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">continuation</td>
<td><p>A <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> reflecting the continuation which is used to continue the call hierarchy. The result of the current continuable is discarded and the given continuation is invoked as shown below.</p><pre class="m-code"><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">atom</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre></td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> representing the next asynchronous result to continue within the asynchronous call hierarchy.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a7001122101ed32f729e39c53d6cb9c7f"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename T, typename E = detail::types::this_thread_executor_tag&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a7001122101ed32f729e39c53d6cb9c7f" class="m-dox-self">fail</a>(</span><span class="m-dox-wrap">T&amp;&amp; callback,
E&amp;&amp; executor = detail::types::this_thread_executor_tag{}) &amp;&amp;</span></span>
</h3>
<p>Main method of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> to catch exceptions and error codes in case the asynchronous control flow failed and was resolved through an error code or exception.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">callback</td>
<td>The callback which is used to process the current asynchronous error result on arrival. In case the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> is using exceptions, the usage is as shown below:</td>
</tr>
<tr>
<td>executor</td>
<td>The optional executor which is used to dispatch the callback. See the description in <code>then</code> above.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with an asynchronous return type depending on the previous result type.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span> <span class="p">})</span>
<span class="p">.</span><span class="n">fail</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">exception_ptr</span> <span class="n">ptr</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// Handle the error here</span>
<span class="k">try</span> <span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">rethrow_exception</span><span class="p">(</span><span class="n">ptr</span><span class="p">);</span>
<span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">exception</span><span class="o">&amp;</span> <span class="n">e</span><span class="p">)</span> <span class="p">{</span>
<span class="n">e</span><span class="p">.</span><span class="n">what</span><span class="p">();</span> <span class="c1">// Handle the exception</span>
<span class="p">}</span>
<span class="p">});</span></pre><p>In case exceptions are disabled, <code>std::error_condition</code> is used as error result instead of <code>std::exception_ptr</code>.</p><pre class="m-code"><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">)</span> <span class="p">{</span> <span class="p">})</span>
<span class="p">.</span><span class="n">fail</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">error_condition</span> <span class="n">error</span><span class="p">)</span> <span class="p">{</span>
<span class="n">error</span><span class="p">.</span><span class="n">message</span><span class="p">();</span> <span class="c1">// Handle the error here</span>
<span class="p">});</span></pre><aside class="m-note m-default"><h4>Since</h4><p>2.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="ac9da66a917e3d6901497d62eb67eaad0"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename OData, typename OAnnotation&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ac9da66a917e3d6901497d62eb67eaad0" class="m-dox-self">fail</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; continuation) &amp;&amp;</span></span>
</h3>
<p>Additional overload of the <a href="classcti_1_1continuable__base.html#a7001122101ed32f729e39c53d6cb9c7f" class="m-dox">continuable_base::<wbr />fail()</a> method which is accepting a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> itself.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">continuation</td>
<td><p>A <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> reflecting the continuation which is used to continue the call hierarchy on errors. The result of the current continuable is discarded and the given continuation is invoked as shown below.</p><pre class="m-code"><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">fail</span><span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span></pre></td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with an asynchronous return type depending on the previous result type.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Since</h4><p>2.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="ad4960d0794abb800f1dfd9a668900149"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename T, typename E = detail::types::this_thread_executor_tag&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ad4960d0794abb800f1dfd9a668900149" class="m-dox-self">next</a>(</span><span class="m-dox-wrap">T&amp;&amp; callback,
E&amp;&amp; executor = detail::types::this_thread_executor_tag{}) &amp;&amp;</span></span>
</h3>
<p>A method which allows to use an overloaded callable for the error as well as the valid result path.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">callback</td>
<td>The callback which is used to process the current asynchronous result and error on arrival.</td>
</tr>
<tr>
<td>executor</td>
<td>The optional executor which is used to dispatch the callback. See the description in <code>then</code> above.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with an asynchronous return type depending on the current result type.</td>
</tr>
</tfoot>
</table>
<pre class="m-code"><span class="k">struct</span> <span class="n">my_callable</span> <span class="p">{</span>
<span class="kt">void</span> <span class="k">operator</span><span class="p">()</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">result</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="k">operator</span><span class="p">()</span> <span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">dispatch_error_tag</span><span class="p">,</span> <span class="n">cti</span><span class="o">::</span><span class="n">error_type</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">}</span>
<span class="c1">// Will receive errors and results</span>
<span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span>
<span class="p">.</span><span class="n">next</span><span class="p">(</span><span class="n">my_callable</span><span class="p">{});</span></pre><aside class="m-note m-default"><h4>Since</h4><p>2.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="abcf4cf105aa17826bcc3c2278f6ea1b5"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename T&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#abcf4cf105aa17826bcc3c2278f6ea1b5" class="m-dox-self">apply</a>(</span><span class="m-dox-wrap">T&amp;&amp; transform) &amp;&amp;</span></span>
</h3>
<p>A method which allows to apply this continuable to the given callable.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">transform</td>
<td>A transform which shall accept this continuable</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>Returns the result of the given transform when this continuable is passed into it.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Since</h4><p>2.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="ae2d35537ea76f421ba4aed86dd849f98"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename T&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ae2d35537ea76f421ba4aed86dd849f98" class="m-dox-self">operator|</a>(</span><span class="m-dox-wrap">T&amp;&amp; right) &amp;&amp;</span></span>
</h3>
<p>The pipe operator | is an alias for the continuable::then method.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">right</td>
<td>The argument on the right-hand side to connect.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>See the corresponding <a href="classcti_1_1continuable__base.html#adf02030d7211ffc4610f3bcb13d2a149" class="m-dox">continuable_base::<wbr />then</a> method for the explanation of the return type.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>Since</h4><p>2.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a80027c1b07600076960ebcb87fd064c1"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename T&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a80027c1b07600076960ebcb87fd064c1" class="m-dox-self">operator|</a>(</span><span class="m-dox-wrap">detail::types::transform&lt;T&gt; transform) &amp;&amp;</span></span>
</h3>
<p>The pipe operator | is an alias for the continuable::apply method.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">transform</td>
<td>The transformer which is applied.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td>See the corresponding <a href="classcti_1_1continuable__base.html#abcf4cf105aa17826bcc3c2278f6ea1b5" class="m-dox">continuable_base::<wbr />apply</a> method for the explanation of the return type.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-info"><h4>Note</h4><p>You may create your own transformation through calling make_transformation.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>3.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a43ad4bfb19234a7856972d97337498db"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename OData, typename OAnnotation&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a43ad4bfb19234a7856972d97337498db" class="m-dox-self">operator&amp;&amp;</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; right) &amp;&amp;</span></span>
</h3>
<p>Invokes both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects parallel and calls the callback with the result of both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">right</td>
<td>The continuable on the right-hand side to connect.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td><p>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with a result type matching the result of the left <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> combined with the right <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>. The returned <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> will be in an intermediate lazy state, further calls to its <a href="classcti_1_1continuable__base.html#a43ad4bfb19234a7856972d97337498db" class="m-dox">continuable_base::<wbr />operator &amp;&amp;</a> will add other <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects to the current invocation chain.</p><pre class="m-code"><span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span> <span class="o">&amp;&amp;</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">atom</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span>
<span class="k">auto</span> <span class="n">request</span> <span class="o">=</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span> <span class="o">&amp;&amp;</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">);</span>
<span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">request</span><span class="p">)</span> <span class="o">&amp;&amp;</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;travis-ci.org&quot;</span><span class="p">))</span>
<span class="c1">// All three requests are invoked in parallel although we added</span>
<span class="c1">// the request to &quot;travis-ci.org&quot; last.</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">atom</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">travis</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre></td>
</tr>
</tfoot>
</table>
<aside class="m-note m-info"><h4>Note</h4><p>The <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects are invoked all at onve, because the <code>all</code> strategy tries to resolve the continuations as fast as possible. Sequential invocation is also supported through the <a href="classcti_1_1continuable__base.html#abaaaf8a35827456fead299851268760e" class="m-dox">continuable_base::<wbr />operator&gt;&gt;</a> method.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="ada74584fb95bf00a50d05072e933c144"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename OData, typename OAnnotation&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ada74584fb95bf00a50d05072e933c144" class="m-dox-self">operator||</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; right) &amp;&amp;</span></span>
</h3>
<p>Invokes both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects parallel and calls the callback once with the first result available.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">right</td>
<td>The continuable on the right-hand side to connect. The right continuable is required to have the same result as the left connected <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td><p>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with a result type matching the combined result which of all connected <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects. The returned <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> will be in an intermediate lazy state, further calls to its <a href="classcti_1_1continuable__base.html#ada74584fb95bf00a50d05072e933c144" class="m-dox">continuable_base::<wbr />operator ||</a> will add other <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects to the current invocation chain.</p><pre class="m-code"><span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span> <span class="o">||</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github_or_atom</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span>
<span class="p">(</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="sc">&#39;A&#39;</span><span class="p">)</span> <span class="o">||</span> <span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">29</span><span class="p">,</span> <span class="sc">&#39;B&#39;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">char</span> <span class="n">b</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre></td>
</tr>
</tfoot>
</table>
<aside class="m-note m-info"><h4>Note</h4><p>The <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects are invoked all at once, however, the callback is only called once with the first result or exception which becomes available.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="abaaaf8a35827456fead299851268760e"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
template&lt;typename OData, typename OAnnotation&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#abaaaf8a35827456fead299851268760e" class="m-dox-self">operator&gt;&gt;</a>(</span><span class="m-dox-wrap"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&lt;OData, OAnnotation&gt;&amp;&amp; right) &amp;&amp;</span></span>
</h3>
<p>Invokes both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects sequential and calls the callback with the result of both <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">right</td>
<td>The continuable on the right-hand side to connect.</td>
</tr>
</tbody>
<tfoot>
<tr>
<th>Returns</th>
<td><p>Returns a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with a result type matching the result of the left <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> combined with the right <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>.</p><pre class="m-code"><span class="p">(</span><span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">)</span> <span class="o">&gt;&gt;</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;atom.io&quot;</span><span class="p">))</span>
<span class="p">.</span><span class="n">then</span><span class="p">([](</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">github</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">atom</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// The callback is called with the result of both requests,</span>
<span class="c1">// however, the request to atom was started after the request</span>
<span class="c1">// to github was finished.</span>
<span class="p">});</span></pre></td>
</tr>
</tfoot>
</table>
<aside class="m-note m-info"><h4>Note</h4><p>The <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> objects are invoked sequential one after the previous one was finished. Parallel invocation is also supported through the <a href="classcti_1_1continuable__base.html#a43ad4bfb19234a7856972d97337498db" class="m-dox">continuable_base::<wbr />operator &amp;&amp;</a> method.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a26ca692e597ebd8beff7d58d8bf584f4"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
</div>
<span class="m-dox-wrap-bumper">void cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a26ca692e597ebd8beff7d58d8bf584f4" class="m-dox-self">done</a>(</span><span class="m-dox-wrap">) &amp;&amp;</span></span>
</h3>
<p>Invokes the continuation chain manually even before the <a href="classcti_1_1continuable__base.html" class="m-dox">cti::<wbr />continuable_base</a> is destructed. This will release the object.</p>
<aside class="m-note m-default"><h4>See also</h4><p><a href="classcti_1_1continuable__base.html#ad52b8e48a62fa038d06faaca58295067" class="m-dox">continuable_base::<wbr />~continuable_base()</a> for further details about the continuation invocation on destruction.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>This method will trigger an assertion if the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> was released already.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a1bd6ce7c083af5faf4b241ada8d6f5f7"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
</div>
<span class="m-dox-wrap-bumper">bool cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a1bd6ce7c083af5faf4b241ada8d6f5f7" class="m-dox-self">is_frozen</a>(</span><span class="m-dox-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
</h3>
<p>Predicate to check whether the <a href="classcti_1_1continuable__base.html" class="m-dox">cti::<wbr />continuable_base</a> is frozen or not.</p>
<table class="m-table m-fullwidth m-flat">
<tfoot>
<tr>
<th style="width: 1%">Returns</th>
<td>Returns true when the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> is frozen.</td>
</tr>
</tfoot>
</table>
<aside class="m-note m-default"><h4>See also</h4><p><a href="classcti_1_1continuable__base.html#a3c8d7fefc2f65fcd474c99d821809d24" class="m-dox">continuable_base::<wbr />freeze</a> for further details.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>This method will trigger an assertion if the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> was released already.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a3c8d7fefc2f65fcd474c99d821809d24"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
</div>
<span class="m-dox-wrap-bumper"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&amp; cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a3c8d7fefc2f65fcd474c99d821809d24" class="m-dox-self">freeze</a>(</span><span class="m-dox-wrap">bool enabled = true) &amp;noexcept</span></span>
</h3>
<p>Prevents the automatic invocation of the continuation chain which happens on destruction of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>. You may still invoke the chain through the <a href="classcti_1_1continuable__base.html#a26ca692e597ebd8beff7d58d8bf584f4" class="m-dox">continuable_base::<wbr />done</a> method.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">enabled</td>
<td>Indicates whether the freeze is enabled or disabled.</td>
</tr>
</tbody>
</table>
<p>This is useful for storing a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> inside a continuation chain while storing it for further usage.</p><aside class="m-note m-default"><h4>See also</h4><p><a href="classcti_1_1continuable__base.html#ad52b8e48a62fa038d06faaca58295067" class="m-dox">continuable_base::<wbr />~continuable_base()</a> for further details about the continuation invocation on destruction.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>This method will trigger an assertion if the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> was released already.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="a193e56e793fb40f56d6c6a942f605972"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
</div>
<span class="m-dox-wrap-bumper"><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>&amp;&amp; cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#a193e56e793fb40f56d6c6a942f605972" class="m-dox-self">freeze</a>(</span><span class="m-dox-wrap">bool enabled = true) &amp;&amp;noexcept</span></span>
</h3>
<p>Prevents the automatic invocation of the continuation chain which happens on destruction of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>. You may still invoke the chain through the <a href="classcti_1_1continuable__base.html#a26ca692e597ebd8beff7d58d8bf584f4" class="m-dox">continuable_base::<wbr />done</a> method.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">enabled</td>
<td>Indicates whether the freeze is enabled or disabled.</td>
</tr>
</tbody>
</table>
<p>This is useful for storing a <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> inside a continuation chain while storing it for further usage.</p><aside class="m-note m-default"><h4>See also</h4><p><a href="classcti_1_1continuable__base.html#ad52b8e48a62fa038d06faaca58295067" class="m-dox">continuable_base::<wbr />~continuable_base()</a> for further details about the continuation invocation on destruction.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>This method will trigger an assertion if the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> was released already.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.0.0</p></aside>
</div></section>
<section class="m-dox-details" id="ac79b103d5c000a3a3d1b98d8adcf58e8"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Data, typename Annotation&gt;
</div>
<span class="m-dox-wrap-bumper">auto cti::<wbr />continuable_base&lt;Data, Annotation&gt;::<wbr /></span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ac79b103d5c000a3a3d1b98d8adcf58e8" class="m-dox-self">operator co_await</a>(</span><span class="m-dox-wrap">) &amp;&amp;</span></span>
</h3>
<p>Implements the operator for awaiting on continuables using <code>co_await</code>.</p>
<p>The operator is only enabled if <code>CONTINUABLE_HAS_EXPERIMENTAL_COROUTINE</code> is defined and the toolchain supports experimental coroutines.</p><p>The return type of the <code>co_await</code> expression is specified as following:</p><table class="m-table"><thead><tr><th>Continuation type</th><th>co_await returns</th></tr></thead><tbody><tr><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;&gt;</code></td><td><code>void</code></td></tr><tr><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;Arg&gt;</code></td><td><code>Arg</code></td></tr><tr><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;Args...&gt;</code></td><td><code>std::tuple&lt;Args...&gt;</code></td></tr></tbody></table><p>When exceptions are used the usage is as intuitive as shown below:</p><pre class="m-code"><span class="c1">// Handling the exception isn&#39;t required and</span>
<span class="c1">// the try catch clause may be omitted.</span>
<span class="k">try</span> <span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">response</span> <span class="o">=</span> <span class="n">co_await</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">);</span>
<span class="p">}</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">exception</span><span class="o">&amp;</span> <span class="n">e</span><span class="p">)</span> <span class="p">{</span>
<span class="n">e</span><span class="p">.</span><span class="n">what</span><span class="p">();</span>
<span class="p">}</span></pre><p>In case the library is configured to use error codes or a custom error type the return type of the co_await expression is changed. The result is returned through an internal proxy object which may be queried for the error object.</p><table class="m-table"><thead><tr><th>Continuation type</th><th>co_await returns</th></tr></thead><tbody><tr><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;&gt;</code></td><td><code>unspecified&lt;void&gt;</code></td></tr><tr><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;Arg&gt;</code></td><td><code>unspecified&lt;Arg&gt;</code></td></tr><tr><td><code><a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> with &lt;Args...&gt;</code></td><td><code>unspecified&lt;std::tuple&lt;Args...&gt;&gt;</code></td></tr></tbody></table><p>The interface of the proxy object is similar to the one proposed in the <code>std::expected</code> proposal:</p><pre class="m-code"><span class="k">if</span> <span class="p">(</span><span class="k">auto</span><span class="o">&amp;&amp;</span> <span class="n">result</span> <span class="o">=</span> <span class="n">co_await</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">))</span> <span class="p">{</span>
<span class="k">auto</span> <span class="n">value</span> <span class="o">=</span> <span class="o">*</span><span class="n">result</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="n">cti</span><span class="o">::</span><span class="n">error_type</span> <span class="n">error</span> <span class="o">=</span> <span class="n">result</span><span class="p">.</span><span class="n">get_exception</span><span class="p">();</span>
<span class="p">}</span>
<span class="k">auto</span> <span class="n">result</span> <span class="o">=</span> <span class="n">co_await</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">);</span>
<span class="kt">bool</span><span class="p">(</span><span class="n">result</span><span class="p">);</span>
<span class="n">result</span><span class="p">.</span><span class="n">is_value</span><span class="p">();</span>
<span class="n">result</span><span class="p">.</span><span class="n">is_exception</span><span class="p">();</span>
<span class="o">*</span><span class="n">result</span><span class="p">;</span> <span class="c1">// Same as result.get_value()</span>
<span class="n">result</span><span class="p">.</span><span class="n">get_value</span><span class="p">();</span>
<span class="n">result</span><span class="p">.</span><span class="n">get_exception</span><span class="p">();</span></pre><aside class="m-note m-info"><h4>Note</h4><p>Using <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a> as return type for coroutines is supported. The coroutine is initially stopped and resumed when the continuation is requested in order to keep the lazy evaluation semantics of the <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />base</a>.</p><pre class="m-code"><span class="n">cti</span><span class="o">::</span><span class="n">continuable</span><span class="o">&lt;&gt;</span> <span class="n">resolve_async_void</span><span class="p">()</span> <span class="p">{</span>
<span class="n">co_await</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">);</span>
<span class="c1">// ...</span>
<span class="n">co_return</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">cti</span><span class="o">::</span><span class="n">continuable</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span> <span class="n">resolve_async</span><span class="p">()</span> <span class="p">{</span>
<span class="n">co_await</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">);</span>
<span class="c1">// ...</span>
<span class="n">co_return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span></pre><p>It&#x27;s possible to return multiple return values from coroutines by wrapping those in a tuple like type:</p><pre class="m-code"><span class="n">cti</span><span class="o">::</span><span class="n">continuable</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">int</span><span class="p">,</span> <span class="kt">int</span><span class="o">&gt;</span> <span class="n">resolve_async_multiple</span><span class="p">()</span> <span class="p">{</span>
<span class="n">co_await</span> <span class="n">http_request</span><span class="p">(</span><span class="s">&quot;github.com&quot;</span><span class="p">);</span>
<span class="c1">// ...</span>
<span class="n">co_return</span> <span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">);</span>
<span class="p">}</span></pre></aside><aside class="m-note m-default"><h4>Since</h4><p>2.0.0</p></aside>
</div></section>
</section>
</div>
</div>
</div>
</article></main>
<div class="m-dox-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-dox-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">&hellip;</div>
</div>
<div class="m-dox-search-content">
<input type="search" id="search-input" placeholder="Loading &hellip;" disabled="disabled" autofocus="autofocus" />
<noscript class="m-text m-danger m-text-center">Unlike everything else in the docs, the search functionality <em>requires</em> JavaScript.</noscript>
<div id="search-help" class="m-text m-dim m-text-center">
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. Navigate through the
list using <span class="m-label m-dim">&darr;</span> and
<span class="m-label m-dim">&uarr;</span>, press
<span class="m-label m-dim">Enter</span> to go.
</div>
<div id="search-notfound" class="m-text m-warning m-text-center">Sorry, nothing was found.</div>
<ul id="search-results"></ul>
</div>
</div>
</div>
</div>
</div>
<script src="search.js"></script>
<script src="searchdata.js" async="async"></script>
<footer><nav>
<div class="m-container">
<div class="m-row">
<div class="m-col-l-10 m-push-l-1">
<b><a href="https://github.com/Naios/continuable">continuable</a></b> - C++14 allocation aware futures</br>Copyright 2015&ndash;2018 <a href="https://github.com/Naios">Denis Blank</a>. Contact the author via <a href="mailto:denis.blank@outlook.com">e-mail</a>.</br>Powered by <a href="http://doxygen.org/">Doxygen</a> and <a href="http://mcss.mosra.cz/">m.css</a>
</div>
</div>
</div>
</nav></footer>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink