coffee/continuable
1
0
Fork 0
mirror of https://github.com/Naios/continuable.git synced 2025-12-06 16:56:44 +08:00
Code Issues Packages Projects Releases Wiki Activity
continuable/group___connections.html
Denis Blank 94dc953ba9 Publish
2023-03-21 21:05:30 +01:00

461 lines
39 KiB
HTML
Raw Permalink Blame History

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Connections module | 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">4.1.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 style="height: 0.9rem;" 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" id="m-navbar-current">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">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 style="height: 0.9rem;" 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>
Connections <span class="m-thin">module</span></h1>
<p>provides functions to connect <a href="classcti_1_1continuable__base.html" class="m-dox">continuable_<wbr />bases</a> through various strategies.</p>
<div class="m-block m-default">
<h3>Contents</h3>
<ul>
<li>
Reference
<ul>
<li><a href="#func-members">Functions</a></li>
</ul>
</li>
</ul>
</div>
<section id="func-members">
<h2><a href="#func-members">Functions</a></h2>
<dl class="m-dox">
<dt>
<div class="m-dox-template">template&lt;typename... Args&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#gaef652b8561f76cad49e83cfa21a71734" class="m-dox">when_all</a>(</span><span class="m-dox-wrap">Args &amp;&amp; ... args) -&gt; auto</span>
</dt>
<dd>Connects the given arguments with an all logic. All continuables contained inside the given nested pack are invoked at once. On completion the final handler is called with the aggregated result of all continuables.</dd>
<dt>
<div class="m-dox-template">template&lt;typename Iterator, std::enable_if_t&lt;detail::range::is_iterator&lt;Iterator&gt;::value&gt;* = nullptr&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#gaa39f871e8aa99953dc83fda92b449024" class="m-dox">when_all</a>(</span><span class="m-dox-wrap">Iterator begin,
Iterator end) -&gt; auto</span>
</dt>
<dd>Connects the given arguments with an all logic. The content of the iterator is moved out and converted to a temporary <code>std::vector</code> which is then passed to when_all.</dd>
<dt>
<div class="m-dox-template">template&lt;typename... Args&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ga481c31024079b6074617c64b16e615dd" class="m-dox">when_seq</a>(</span><span class="m-dox-wrap">Args &amp;&amp; ... args) -&gt; auto</span>
</dt>
<dd>Connects the given arguments with a sequential logic. All continuables contained inside the given nested pack are invoked one after one. On completion the final handler is called with the aggregated result of all continuables.</dd>
<dt>
<div class="m-dox-template">template&lt;typename Iterator, std::enable_if_t&lt;detail::range::is_iterator&lt;Iterator&gt;::value&gt;* = nullptr&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ga1d52caeca48122b5aebb276d0d47805a" class="m-dox">when_seq</a>(</span><span class="m-dox-wrap">Iterator begin,
Iterator end) -&gt; auto</span>
</dt>
<dd>Connects the given arguments with a sequential logic. The content of the iterator is moved out and converted to a temporary <code>std::vector</code> which is then passed to when_seq.</dd>
<dt>
<div class="m-dox-template">template&lt;typename... Args&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ga313760e876d0cbc766b41f6b192544bb" class="m-dox">when_any</a>(</span><span class="m-dox-wrap">Args &amp;&amp; ... args) -&gt; auto</span>
</dt>
<dd>Connects the given arguments with an any logic. All continuables contained inside the given nested pack are invoked at once. On completion of one continuable the final handler is called with the result of the resolved continuable.</dd>
<dt>
<div class="m-dox-template">template&lt;typename Iterator, std::enable_if_t&lt;detail::range::is_iterator&lt;Iterator&gt;::value&gt;* = nullptr&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ga580b6b0d4fd31371b2f37e0dc5bf039b" class="m-dox">when_any</a>(</span><span class="m-dox-wrap">Iterator begin,
Iterator end) -&gt; auto</span>
</dt>
<dd>Connects the given arguments with an any logic. The content of the iterator is moved out and converted to a temporary <code>std::vector</code> which is then passed to when_all.</dd>
<dt>
<div class="m-dox-template">template&lt;template&lt;typename, typename&gt; class C = std::vector, typename First, typename... Args&gt;</div>
<span class="m-dox-wrap-bumper">auto <a href="#ga4f6ecedf4b4ccd5e1c28d937ad717b32" class="m-dox">populate</a>(</span><span class="m-dox-wrap">First&amp;&amp; first,
Args &amp;&amp; ... args) -&gt; C&lt;std::decay_t&lt;First&gt;, std::allocator&lt;std::decay_t&lt;First&gt;&gt;&gt;</span>
</dt>
<dd>Populates a homogeneous container from the given arguments. All arguments need to be convertible to the first one, by default <code>std::vector</code> is used as container type.</dd>
</dl>
</section>
<section>
<h2>Function documentation</h2>
<section class="m-dox-details" id="gaef652b8561f76cad49e83cfa21a71734"><div>
<h3>
<div class="m-dox-template">
template&lt;typename... Args&gt;
</div>
<span class="m-dox-wrap-bumper">auto </span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#gaef652b8561f76cad49e83cfa21a71734" class="m-dox-self">when_all</a>(</span><span class="m-dox-wrap">Args &amp;&amp; ... args)</span></span>
</h3>
<p>Connects the given arguments with an all logic. All continuables contained inside the given nested pack are invoked at once. On completion the final handler is called with the aggregated result of all continuables.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">args</td>
<td><p>Arbitrary arguments which are connected. Every type is allowed as arguments, continuables may be contained inside tuple like types (<code>std::tuple</code>) or in homogeneous containers such as <code>std::vector</code>. Non continuable arguments are preserved and passed to the final result as shown below:</p><pre class="m-code"><span class="n">cti</span><span class="o">::</span><span class="n">when_all</span><span class="p">(</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</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="c1">//&lt; See this plain value</span>
<span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span> <span class="c1">// Creates a runtime</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">4</span><span class="p">)),</span> <span class="c1">// sized container.</span>
<span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">5</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">r0</span><span class="p">,</span> <span class="kt">int</span> <span class="n">r1</span><span class="p">,</span> <span class="kt">int</span> <span class="n">r2</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span> <span class="n">r34</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="n">tuple</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">tuple</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;&gt;</span> <span class="n">r5</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre></td>
</tr>
</tbody>
</table>
<aside class="m-note m-default"><h4>See also</h4><p><a href="classcti_1_1continuable__base.html#ad5cbff40fcd03a6451eae06d310f1439" class="m-dox">continuable_base::<wbr />operator&amp;&amp;</a> for details.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.1.0</p></aside>
</div></section>
<section class="m-dox-details" id="gaa39f871e8aa99953dc83fda92b449024"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Iterator, std::enable_if_t&lt;detail::range::is_iterator&lt;Iterator&gt;::value&gt;* = nullptr&gt;
</div>
<span class="m-dox-wrap-bumper">auto </span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#gaa39f871e8aa99953dc83fda92b449024" class="m-dox-self">when_all</a>(</span><span class="m-dox-wrap">Iterator begin,
Iterator end)</span></span>
</h3>
<p>Connects the given arguments with an all logic. The content of the iterator is moved out and converted to a temporary <code>std::vector</code> which is then passed to when_all.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">begin</td>
<td>The begin iterator to the range which will be moved out and used as the arguments to the all connection</td>
</tr>
<tr>
<td>end</td>
<td>The end iterator to the range which will be moved out and used as the arguments to the all connection</td>
</tr>
</tbody>
</table>
<pre class="m-code"><span class="c1">// cti::populate just creates a std::vector from the two continuables.</span>
<span class="k">auto</span> <span class="n">v</span> <span class="o">=</span> <span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">1</span><span class="p">));</span>
<span class="n">cti</span><span class="o">::</span><span class="n">when_all</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">v</span><span class="p">.</span><span class="n">end</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">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span> <span class="n">r01</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre><aside class="m-note m-default"><h4>See also</h4><p><a href="group___connections.html#gaef652b8561f76cad49e83cfa21a71734" class="m-dox">when_<wbr />all</a> for details.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>Prefer to invoke when_all with the whole container the iterators were taken from, since this saves us the creation of a temporary storage.</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="ga481c31024079b6074617c64b16e615dd"><div>
<h3>
<div class="m-dox-template">
template&lt;typename... Args&gt;
</div>
<span class="m-dox-wrap-bumper">auto </span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ga481c31024079b6074617c64b16e615dd" class="m-dox-self">when_seq</a>(</span><span class="m-dox-wrap">Args &amp;&amp; ... args)</span></span>
</h3>
<p>Connects the given arguments with a sequential logic. All continuables contained inside the given nested pack are invoked one after one. On completion the final handler is called with the aggregated result of all continuables.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">args</td>
<td><p>Arbitrary arguments which are connected. Every type is allowed as arguments, continuables may be contained inside tuple like types (<code>std::tuple</code>) or in homogeneous containers such as <code>std::vector</code>. Non continuable arguments are preserved and passed to the final result as shown below:</p><pre class="m-code"><span class="n">cti</span><span class="o">::</span><span class="n">when_seq</span><span class="p">(</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</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="c1">//&lt; See this plain value</span>
<span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span> <span class="c1">// Creates a runtime</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">4</span><span class="p">)),</span> <span class="c1">// sized container.</span>
<span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">5</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">r0</span><span class="p">,</span> <span class="kt">int</span> <span class="n">r1</span><span class="p">,</span> <span class="kt">int</span> <span class="n">r2</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span> <span class="n">r34</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="n">tuple</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">tuple</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;&gt;</span> <span class="n">r5</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre></td>
</tr>
</tbody>
</table>
<aside class="m-note m-default"><h4>See also</h4><p><a href="classcti_1_1continuable__base.html#abaaaf8a35827456fead299851268760e" class="m-dox">continuable_base::<wbr />operator&gt;&gt;</a> for details.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.1.0</p></aside>
</div></section>
<section class="m-dox-details" id="ga1d52caeca48122b5aebb276d0d47805a"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Iterator, std::enable_if_t&lt;detail::range::is_iterator&lt;Iterator&gt;::value&gt;* = nullptr&gt;
</div>
<span class="m-dox-wrap-bumper">auto </span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ga1d52caeca48122b5aebb276d0d47805a" class="m-dox-self">when_seq</a>(</span><span class="m-dox-wrap">Iterator begin,
Iterator end)</span></span>
</h3>
<p>Connects the given arguments with a sequential logic. The content of the iterator is moved out and converted to a temporary <code>std::vector</code> which is then passed to when_seq.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">begin</td>
<td>The begin iterator to the range which will be moved out and used as the arguments to the sequential connection</td>
</tr>
<tr>
<td>end</td>
<td>The end iterator to the range which will be moved out and used as the arguments to the sequential connection</td>
</tr>
</tbody>
</table>
<pre class="m-code"><span class="c1">// cti::populate just creates a std::vector from the two continuables.</span>
<span class="k">auto</span> <span class="n">v</span> <span class="o">=</span> <span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">1</span><span class="p">));</span>
<span class="n">cti</span><span class="o">::</span><span class="n">when_seq</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">v</span><span class="p">.</span><span class="n">end</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">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span> <span class="n">r01</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre><aside class="m-note m-default"><h4>See also</h4><p><a href="group___connections.html#ga481c31024079b6074617c64b16e615dd" class="m-dox">when_<wbr />seq</a> for details.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>Prefer to invoke when_seq with the whole container the iterators were taken from, since this saves us the creation of a temporary storage.</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="ga313760e876d0cbc766b41f6b192544bb"><div>
<h3>
<div class="m-dox-template">
template&lt;typename... Args&gt;
</div>
<span class="m-dox-wrap-bumper">auto </span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ga313760e876d0cbc766b41f6b192544bb" class="m-dox-self">when_any</a>(</span><span class="m-dox-wrap">Args &amp;&amp; ... args)</span></span>
</h3>
<p>Connects the given arguments with an any logic. All continuables contained inside the given nested pack are invoked at once. On completion of one continuable the final handler is called with the result of the resolved continuable.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">args</td>
<td><p>Arbitrary arguments which are connected. Every type is allowed as arguments, continuables may be contained inside tuple like types (<code>std::tuple</code>) or in homogeneous containers such as <code>std::vector</code>. Non continuable arguments are preserved and passed to the final result as shown below:</p><pre class="m-code"><span class="n">cti</span><span class="o">::</span><span class="n">when_any</span><span class="p">(</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</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="c1">//&lt; See this plain value</span>
<span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span> <span class="c1">// Creates a runtime</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">4</span><span class="p">)),</span> <span class="c1">// sized container.</span>
<span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_tuple</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">5</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">r0</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre></td>
</tr>
</tbody>
</table>
<aside class="m-note m-default"><h4>See also</h4><p><a href="classcti_1_1continuable__base.html#ada74584fb95bf00a50d05072e933c144" class="m-dox">continuable_base::<wbr />operator||</a> for details.</p></aside><aside class="m-note m-default"><h4>Since</h4><p>1.1.0</p></aside>
</div></section>
<section class="m-dox-details" id="ga580b6b0d4fd31371b2f37e0dc5bf039b"><div>
<h3>
<div class="m-dox-template">
template&lt;typename Iterator, std::enable_if_t&lt;detail::range::is_iterator&lt;Iterator&gt;::value&gt;* = nullptr&gt;
</div>
<span class="m-dox-wrap-bumper">auto </span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ga580b6b0d4fd31371b2f37e0dc5bf039b" class="m-dox-self">when_any</a>(</span><span class="m-dox-wrap">Iterator begin,
Iterator end)</span></span>
</h3>
<p>Connects the given arguments with an any logic. The content of the iterator is moved out and converted to a temporary <code>std::vector</code> which is then passed to when_all.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">begin</td>
<td>The begin iterator to the range which will be moved out and used as the arguments to the all connection</td>
</tr>
<tr>
<td>end</td>
<td>The end iterator to the range which will be moved out and used as the arguments to the all connection</td>
</tr>
</tbody>
</table>
<pre class="m-code"><span class="c1">// cti::populate just creates a std::vector from the two continuables.</span>
<span class="k">auto</span> <span class="n">v</span> <span class="o">=</span> <span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">1</span><span class="p">));</span>
<span class="n">cti</span><span class="o">::</span><span class="n">when_any</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">v</span><span class="p">.</span><span class="n">end</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">r01</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre><aside class="m-note m-default"><h4>See also</h4><p><a href="group___connections.html#ga313760e876d0cbc766b41f6b192544bb" class="m-dox">when_<wbr />any</a> for details.</p></aside><aside class="m-note m-warning"><h4>Attention</h4><p>Prefer to invoke when_any with the whole container the iterators were taken from, since this saves us the creation of a temporary storage.</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="ga4f6ecedf4b4ccd5e1c28d937ad717b32"><div>
<h3>
<div class="m-dox-template">
template&lt;template&lt;typename, typename&gt; class C = std::vector, typename First, typename... Args&gt;
</div>
<span class="m-dox-wrap-bumper">C&lt;std::decay_t&lt;First&gt;, std::allocator&lt;std::decay_t&lt;First&gt;&gt;&gt; </span><span class="m-dox-wrap"><span class="m-dox-wrap-bumper"><a href="#ga4f6ecedf4b4ccd5e1c28d937ad717b32" class="m-dox-self">populate</a>(</span><span class="m-dox-wrap">First&amp;&amp; first,
Args &amp;&amp; ... args)</span></span>
</h3>
<p>Populates a homogeneous container from the given arguments. All arguments need to be convertible to the first one, by default <code>std::vector</code> is used as container type.</p>
<table class="m-table m-fullwidth m-flat">
<thead>
<tr><th colspan="2">Template parameters</th></tr>
</thead>
<tbody>
<tr>
<td style="width: 1%">C</td>
<td>The container type which is used to store the arguments into.</td>
</tr>
<tr>
<td>First</td>
<td></td>
</tr>
<tr>
<td>Args</td>
<td></td>
</tr>
</tbody>
</table>
<p>This method mainly helps to create a homogeneous container from a runtime known count of continuables which type isn&#x27;t exactly known. All continuables which are passed to this function should be originating from the same source or a method called with the same types of arguments:</p><pre class="m-code"><span class="k">auto</span> <span class="n">container</span> <span class="o">=</span> <span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">1</span><span class="p">)),</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="mi">5</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="c1">// You may add more continuables to the container afterwards</span>
<span class="n">container</span><span class="p">.</span><span class="n">emplace_back</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="n">i</span><span class="p">));</span>
<span class="p">}</span>
<span class="n">cti</span><span class="o">::</span><span class="n">when_any</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">container</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="p">)</span> <span class="p">{</span>
<span class="c1">// ...</span>
<span class="p">});</span></pre><p>Additionally it is possible to change the targeted container as below:</p><pre class="m-code"><span class="k">auto</span> <span class="n">container</span> <span class="o">=</span> <span class="n">cti</span><span class="o">::</span><span class="n">populate</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">list</span><span class="o">&gt;</span><span class="p">(</span><span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span>
<span class="n">cti</span><span class="o">::</span><span class="n">make_ready_continuable</span><span class="p">(</span><span class="mi">1</span><span class="p">)),</span></pre><aside class="m-note m-default"><h4>Since</h4><p>3.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">
<form>
<input type="search" name="q" id="search-input" placeholder="Loading &hellip;" disabled="disabled" autofocus="autofocus" autocomplete="off" spellcheck="false" />
</form>
<noscript class="m-text m-danger m-text-center">Unlike everything else in the docs, the search functionality <em>requires</em> JavaScript.</noscript>
<div id="search-help" class="m-text m-dim m-text-center">
<p class="m-noindent">Search for symbols, directories, files, pages or
modules. You can omit any prefix from the symbol or file path; adding a
<code>:</code> or <code>/</code> suffix lists all members of given symbol or
directory.</p>
<p class="m-noindent">Use <span class="m-label m-dim">&darr;</span>
/ <span class="m-label m-dim">&uarr;</span> to navigate through the list,
<span class="m-label m-dim">Enter</span> to go.
<span class="m-label m-dim">Tab</span> autocompletes common prefix, you can
copy a link to the result using <span class="m-label m-dim">⌘</span>
<span class="m-label m-dim">L</span> while <span class="m-label m-dim">⌘</span>
<span class="m-label m-dim">M</span> produces a Markdown link.</p>
</div>
<div 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;2020
<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