MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-12-26 15:33:54 +01:00
Code Issues Releases Wiki Activity

ircd::ctx: Break down when() templates; fix mutability.

Browse source
This commit is contained in:
Jason Volk 2018-08-30 19:54:50 -07:00
parent 4b2ff18f6c
commit 5f9c12bddc
1 changed files with 89 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

161
include/ircd/ctx/when.h
View file

@ -13,55 +13,18 @@
namespace ircd::ctx
{
template<class it> future<it> when_any(it first, const it &last);
template<class it> future<void> when_all(it first, const it &last);
template<class it> future<it> when_any(it first, const it &last);
}
/// Returns a future which becomes ready when all of the futures in the
/// collection become ready. This future has a void payload to minimize
/// its cost since this indication is positively unate.
template<class it>
ircd::ctx::future<void>
ircd::ctx::when_all(it first,
const it &last)
// Internal interface
namespace ircd::ctx::when
{
static const auto then
{
[](promise<void> &p)
{
if(!p.valid())
return;
if(refcount(p.state()) < 2)
return p.set_value();
return remove(p.state(), p);
}
};
promise<void> p;
const auto set_then
{
[&p](it &f)
{
state(*f).then = [p]
(shared_state_base &sb) mutable
{
if(sb.then)
then(p);
};
}
};
future<void> ret(p);
for(; first != last; ++first)
if(is(state(*first), future_state::PENDING))
set_then(first);
if(refcount(p.state()) <= 1)
p.set_value();
return ret;
template<class T> auto &state(const future<T> &);
void all_then(promise<void> &p);
template<class it> void any_then(promise<it> &p, it &f);
template<class it> void set_all_then(promise<void> &p, it &f);
template<class it> void set_any_then(promise<it> &p, it &f);
}
/// Returns a future which becomes ready when any of the futures in the
@ -79,47 +42,101 @@ ircd::ctx::future<it>
ircd::ctx::when_any(it first,
const it &last)
{
static const auto then
{
[](promise<it> &p, it &f)
{
if(!p.valid())
return;
set(state(*f), future_state::OBSERVED);
p.set_value(f);
}
};
promise<it> p;
const auto set_then
{
[&p](it &f)
{
state(*f).then = [p, f] // alloc
(shared_state_base &sb) mutable
{
if(sb.then)
then(p, f);
};
}
};
future<it> ret(p);
for(auto f(first); f != last; ++f)
if(is(state(*f), future_state::READY))
{
set(state(*f), future_state::OBSERVED);
set(when::state(*f), future_state::OBSERVED);
p.set_value(f);
return ret;
}
for(; first != last; ++first)
if(is(state(*first), future_state::PENDING))
set_then(first);
when::set_any_then(p, first);
if(refcount(p.state()) <= 1)
p.set_value(first);
return ret;
}
/// Returns a future which becomes ready when all of the futures in the
/// collection become ready. This future has a void payload to minimize
/// its cost since this indication is positively unate.
template<class it>
ircd::ctx::future<void>
ircd::ctx::when_all(it first,
const it &last)
{
promise<void> p;
future<void> ret(p);
for(; first != last; ++first)
if(is(state(*first), future_state::PENDING))
when::set_all_then(p, first);
if(refcount(p.state()) <= 1)
p.set_value();
return ret;
}
template<class it>
void
ircd::ctx::when::set_any_then(promise<it> &p,
it &f)
{
when::state(*f).then = [p, f] // TODO: quash this alloc
(shared_state_base &sb) mutable
{
if(sb.then)
any_then(p, f);
};
}
template<class it>
void
ircd::ctx::when::set_all_then(promise<void> &p,
it &f)
{
when::state(*f).then = [p] // TODO: quash this alloc
(shared_state_base &sb) mutable
{
if(sb.then)
all_then(p);
};
}
template<class it>
void
ircd::ctx::when::any_then(promise<it> &p,
it &f)
{
if(!p.valid())
return;
set(when::state(*f), future_state::OBSERVED);
p.set_value(f);
}
inline void
ircd::ctx::when::all_then(promise<void> &p)
{
if(!p.valid())
return;
if(refcount(p.state()) < 2)
return p.set_value();
return remove(p.state(), p);
}
/// In order for this template to be reusable with std::set iterations we
/// have to make a const_cast at some point; this internal function does that.
template<class T>
auto &
ircd::ctx::when::state(const future<T> &f)
{
return const_cast<future<T> &>(f).state();
}