typename std::iterator_traits<InputIterator>::value_type()>::type>
>::type
>
-whenN(InputIterator first, InputIterator last, size_t n) {
+collectN(InputIterator first, InputIterator last, size_t n) {
typedef typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type Result;
assert(n > 0);
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type, void
>::value, std::vector<size_t>>::type
-whenN(InputIterator first, InputIterator last, size_t n) {
+collectN(InputIterator first, InputIterator last, size_t n) {
assert(n > 0);
assert(n <= std::distance(first, last));
>::value,
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type>::type>
-inline whenAll(InputIterator first, InputIterator last) {
+inline collectAll(InputIterator first, InputIterator last) {
typedef typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type Result;
size_t n = std::distance(first, last);
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type, void
>::value, void>::type
-inline whenAll(InputIterator first, InputIterator last) {
+inline collectAll(InputIterator first, InputIterator last) {
forEach(first, last, [] (size_t id) {});
}
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type>
>::type
-inline whenAny(InputIterator first, InputIterator last) {
- auto result = whenN(first, last, 1);
+inline collectAny(InputIterator first, InputIterator last) {
+ auto result = collectN(first, last, 1);
assert(result.size() == 1);
return std::move(result[0]);
}
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type, void
>::value, size_t>::type
-inline whenAny(InputIterator first, InputIterator last) {
- auto result = whenN(first, last, 1);
+inline collectAny(InputIterator first, InputIterator last) {
+ auto result = collectN(first, last, 1);
assert(result.size() == 1);
return std::move(result[0]);
}
typename std::iterator_traits<InputIterator>::value_type()>::type>
>::type
>
-inline whenN(InputIterator first, InputIterator last, size_t n);
+inline collectN(InputIterator first, InputIterator last, size_t n);
/**
- * whenN specialization for functions returning void
+ * collectN specialization for functions returning void
*
* @param first Range of tasks to be scheduled
* @param last
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type, void
>::value, std::vector<size_t>>::type
-inline whenN(InputIterator first, InputIterator last, size_t n);
+inline collectN(InputIterator first, InputIterator last, size_t n);
/**
* Schedules several tasks and blocks until all of these tasks are completed.
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type>::type
>
-inline whenAll(InputIterator first, InputIterator last);
+inline collectAll(InputIterator first, InputIterator last);
/**
- * whenAll specialization for functions returning void
+ * collectAll specialization for functions returning void
*
* @param first Range of tasks to be scheduled
* @param last
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type, void
>::value, void>::type
-inline whenAll(InputIterator first, InputIterator last);
+inline collectAll(InputIterator first, InputIterator last);
/**
* Schedules several tasks and blocks until one of them is completed.
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type>
>::type
-inline whenAny(InputIterator first, InputIterator last);
+inline collectAny(InputIterator first, InputIterator last);
/**
* WhenAny specialization for functions returning void.
typename std::result_of<
typename std::iterator_traits<InputIterator>::value_type()>::type, void
>::value, size_t>::type
-inline whenAny(InputIterator first, InputIterator last);
+inline collectAny(InputIterator first, InputIterator last);
}}
loopController.loop(std::move(loopFunc));
}
-TEST(FiberManager, whenN) {
+TEST(FiberManager, collectN) {
std::vector<Promise<int>> pendingFibers;
bool taskAdded = false;
);
}
- auto results = whenN(funcs.begin(), funcs.end(), 2);
+ auto results = collectN(funcs.begin(), funcs.end(), 2);
EXPECT_EQ(2, results.size());
EXPECT_EQ(1, pendingFibers.size());
for (size_t i = 0; i < 2; ++i) {
loopController.loop(std::move(loopFunc));
}
-TEST(FiberManager, whenNThrow) {
+TEST(FiberManager, collectNThrow) {
std::vector<Promise<int>> pendingFibers;
bool taskAdded = false;
}
try {
- whenN(funcs.begin(), funcs.end(), 2);
+ collectN(funcs.begin(), funcs.end(), 2);
} catch (...) {
EXPECT_EQ(1, pendingFibers.size());
}
loopController.loop(std::move(loopFunc));
}
-TEST(FiberManager, whenNVoid) {
+TEST(FiberManager, collectNVoid) {
std::vector<Promise<int>> pendingFibers;
bool taskAdded = false;
);
}
- auto results = whenN(funcs.begin(), funcs.end(), 2);
+ auto results = collectN(funcs.begin(), funcs.end(), 2);
EXPECT_EQ(2, results.size());
EXPECT_EQ(1, pendingFibers.size());
}
loopController.loop(std::move(loopFunc));
}
-TEST(FiberManager, whenNVoidThrow) {
+TEST(FiberManager, collectNVoidThrow) {
std::vector<Promise<int>> pendingFibers;
bool taskAdded = false;
}
try {
- whenN(funcs.begin(), funcs.end(), 2);
+ collectN(funcs.begin(), funcs.end(), 2);
} catch (...) {
EXPECT_EQ(1, pendingFibers.size());
}
loopController.loop(std::move(loopFunc));
}
-TEST(FiberManager, whenAll) {
+TEST(FiberManager, collectAll) {
std::vector<Promise<int>> pendingFibers;
bool taskAdded = false;
);
}
- auto results = whenAll(funcs.begin(), funcs.end());
+ auto results = collectAll(funcs.begin(), funcs.end());
EXPECT_TRUE(pendingFibers.empty());
for (size_t i = 0; i < 3; ++i) {
EXPECT_EQ(i*2+1, results[i]);
loopController.loop(std::move(loopFunc));
}
-TEST(FiberManager, whenAllVoid) {
+TEST(FiberManager, collectAllVoid) {
std::vector<Promise<int>> pendingFibers;
bool taskAdded = false;
);
}
- whenAll(funcs.begin(), funcs.end());
+ collectAll(funcs.begin(), funcs.end());
EXPECT_TRUE(pendingFibers.empty());
}
);
loopController.loop(std::move(loopFunc));
}
-TEST(FiberManager, whenAny) {
+TEST(FiberManager, collectAny) {
std::vector<Promise<int>> pendingFibers;
bool taskAdded = false;
);
}
- auto result = whenAny(funcs.begin(), funcs.end());
+ auto result = collectAny(funcs.begin(), funcs.end());
EXPECT_EQ(2, pendingFibers.size());
EXPECT_EQ(2, result.first);
EXPECT_EQ(2*2+1, result.second);
local<Data>().value = 44;
};
std::vector<std::function<void()>> tasks{task};
- whenAny(tasks.begin(), tasks.end());
+ collectAny(tasks.begin(), tasks.end());
EXPECT_EQ(43, local<Data>().value);
});
template <typename... Fs>
typename detail::VariadicContext<
typename std::decay<Fs>::type::value_type...>::type
-whenAll(Fs&&... fs) {
+collectAll(Fs&&... fs) {
auto ctx =
new detail::VariadicContext<typename std::decay<Fs>::type::value_type...>();
ctx->total = sizeof...(fs);
auto f_saved = ctx->p.getFuture();
- detail::whenAllVariadicHelper(ctx,
+ detail::collectAllVariadicHelper(ctx,
std::forward<typename std::decay<Fs>::type>(fs)...);
return f_saved;
}
Future<
std::vector<
Try<typename std::iterator_traits<InputIterator>::value_type::value_type>>>
-whenAll(InputIterator first, InputIterator last) {
+collectAll(InputIterator first, InputIterator last) {
typedef
typename std::iterator_traits<InputIterator>::value_type::value_type T;
Try<
typename
std::iterator_traits<InputIterator>::value_type::value_type> > >
-whenAny(InputIterator first, InputIterator last) {
+collectAny(InputIterator first, InputIterator last) {
typedef
typename std::iterator_traits<InputIterator>::value_type::value_type T;
template <class InputIterator>
Future<std::vector<std::pair<size_t, Try<typename
std::iterator_traits<InputIterator>::value_type::value_type>>>>
-whenN(InputIterator first, InputIterator last, size_t n) {
+collectN(InputIterator first, InputIterator last, size_t n) {
typedef typename
std::iterator_traits<InputIterator>::value_type::value_type T;
typedef std::vector<std::pair<size_t, Try<T>>> V;
typedef isTry<Arg> IsTry;
- return whenAll(first, last)
+ return collectAll(first, last)
.then([initial, func](std::vector<Try<ItT>>& vals) mutable {
for (auto& val : vals) {
initial = func(std::move(initial),
});
for (++first; first != last; ++first) {
- f = whenAll(f, *first).then([func](std::tuple<Try<T>, Try<ItT>>& t) {
+ f = collectAll(f, *first).then([func](std::tuple<Try<T>, Try<ItT>>& t) {
return func(std::move(std::get<0>(t).value()),
// Either return a ItT&& or a Try<ItT>&& depending
// on the type of the argument of func.
template <class T>
Future<T> Future<T>::delayed(Duration dur, Timekeeper* tk) {
- return whenAll(*this, futures::sleep(dur, tk))
+ return collectAll(*this, futures::sleep(dur, tk))
.then([](std::tuple<Try<T>, Try<void>> tup) {
Try<T>& t = std::get<0>(tup);
return makeFuture<T>(std::move(t));
template <class T>
Future<bool> Future<T>::willEqual(Future<T>& f) {
- return whenAll(*this, f).then([](const std::tuple<Try<T>, Try<T>>& t) {
+ return collectAll(*this, f).then([](const std::tuple<Try<T>, Try<T>>& t) {
if (std::get<0>(t).hasValue() && std::get<1>(t).hasValue()) {
return std::get<0>(t).value() == std::get<1>(t).value();
} else {
template <class InputIterator>
Future<std::vector<Try<
typename std::iterator_traits<InputIterator>::value_type::value_type>>>
-whenAll(InputIterator first, InputIterator last);
+collectAll(InputIterator first, InputIterator last);
/// This version takes a varying number of Futures instead of an iterator.
/// The return type for (Future<T1>, Future<T2>, ...) input
template <typename... Fs>
typename detail::VariadicContext<
typename std::decay<Fs>::type::value_type...>::type
-whenAll(Fs&&... fs);
+collectAll(Fs&&... fs);
-/// Like whenAll, but will short circuit on the first exception. Thus, the
+/// Like collectAll, but will short circuit on the first exception. Thus, the
/// type of the returned Future is std::vector<T> instead of
/// std::vector<Try<T>>
template <class InputIterator>
Future<std::pair<
size_t,
Try<typename std::iterator_traits<InputIterator>::value_type::value_type>>>
-whenAny(InputIterator first, InputIterator last);
+collectAny(InputIterator first, InputIterator last);
/** when n Futures have completed, the Future completes with a vector of
the index and Try of those n Futures (the indices refer to the original
Future<std::vector<std::pair<
size_t,
Try<typename std::iterator_traits<InputIterator>::value_type::value_type>>>>
-whenN(InputIterator first, InputIterator last, size_t n);
+collectN(InputIterator first, InputIterator last, size_t n);
template <typename F, typename T, typename ItT>
using MaybeTryArg = typename std::conditional<
Futures is a futures-based async framework inspired by [Twitter's Finagle](http://twitter.github.io/finagle/) (which is in scala), and (loosely) building upon the existing (but anemic) Futures code found in the C++11 standard ([`std::future`](http://en.cppreference.com/w/cpp/thread/future)) and [`boost::future`](http://www.boost.org/doc/libs/1_53_0/boost/thread/future.hpp) (especially >= 1.53.0). Although inspired by the std::future interface, it is not syntactically drop-in compatible because some ideas didn't translate well enough and we decided to break from the API. But semantically, it should be straightforward to translate from existing std::future code to Futures.
-The primary semantic differences are that folly's Futures and Promises are not threadsafe; and as does `boost::future`, folly::Futures support continuing callbacks (`then()`) and there are helper methods `whenAll()` and `whenAny()` which are important compositional building blocks.
+The primary semantic differences are that folly's Futures and Promises are not threadsafe; and as does `boost::future`, folly::Futures support continuing callbacks (`then()`) and there are helper methods `collectAll()` and `collectAny()` which are important compositional building blocks.
## Brief Synopsis
for (auto& key : keys) {
futs.push_back(mc.get(key));
}
-auto all = whenAll(futs.begin(), futs.end());
+auto all = collectAll(futs.begin(), futs.end());
vector<Future<GetReply>> futs;
for (auto& key : keys) {
futs.push_back(mc.get(key));
}
-auto any = whenAny(futs.begin(), futs.end());
+auto any = collectAny(futs.begin(), futs.end());
```
-`all` and `any` are Futures (for the exact type and usage see the header files). They will be complete when all/one of `futs` are complete, respectively. (There is also `whenN()` for when you need *some*.)
+`all` and `any` are Futures (for the exact type and usage see the header files). They will be complete when all/one of `futs` are complete, respectively. (There is also `collectN()` for when you need *some*.)
Second, we can attach callbacks to a Future, and chain them together monadically. An example will clarify:
template <typename... Ts, typename THead, typename... Fs>
typename std::enable_if<sizeof...(Fs) == 0, void>::type
-whenAllVariadicHelper(VariadicContext<Ts...> *ctx, THead&& head, Fs&&... tail) {
+collectAllVariadicHelper(VariadicContext<Ts...> *ctx, THead&& head, Fs&&... tail) {
head.setCallback_([ctx](Try<typename THead::value_type>&& t) {
std::get<sizeof...(Ts) - sizeof...(Fs) - 1>(ctx->results) = std::move(t);
if (++ctx->count == ctx->total) {
template <typename... Ts, typename THead, typename... Fs>
typename std::enable_if<sizeof...(Fs) != 0, void>::type
-whenAllVariadicHelper(VariadicContext<Ts...> *ctx, THead&& head, Fs&&... tail) {
+collectAllVariadicHelper(VariadicContext<Ts...> *ctx, THead&& head, Fs&&... tail) {
head.setCallback_([ctx](Try<typename THead::value_type>&& t) {
std::get<sizeof...(Ts) - sizeof...(Fs) - 1>(ctx->results) = std::move(t);
if (++ctx->count == ctx->total) {
}
});
// template tail-recursion
- whenAllVariadicHelper(ctx, std::forward<Fs>(tail)...);
+ collectAllVariadicHelper(ctx, std::forward<Fs>(tail)...);
}
template <typename T>
EXPECT_EQ(7, f.value());
}
-TEST(Future, whenAll) {
+TEST(Future, collectAll) {
// returns a vector variant
{
vector<Promise<int>> promises(10);
for (auto& p : promises)
futures.push_back(p.getFuture());
- auto allf = whenAll(futures.begin(), futures.end());
+ auto allf = collectAll(futures.begin(), futures.end());
random_shuffle(promises.begin(), promises.end());
for (auto& p : promises) {
for (auto& p : promises)
futures.push_back(p.getFuture());
- auto allf = whenAll(futures.begin(), futures.end());
+ auto allf = collectAll(futures.begin(), futures.end());
promises[0].setValue(42);
for (auto& p : promises)
futures.push_back(p.getFuture());
- auto allf = whenAll(futures.begin(), futures.end())
+ auto allf = collectAll(futures.begin(), futures.end())
.then([](Try<vector<Try<void>>>&& ts) {
for (auto& f : ts.value())
f.value();
}
}
-TEST(Future, whenAny) {
+TEST(Future, collectAny) {
{
vector<Promise<int>> promises(10);
vector<Future<int>> futures;
EXPECT_FALSE(f.isReady());
}
- auto anyf = whenAny(futures.begin(), futures.end());
+ auto anyf = collectAny(futures.begin(), futures.end());
/* futures were moved in, so these are invalid now */
EXPECT_FALSE(anyf.isReady());
EXPECT_FALSE(f.isReady());
}
- auto anyf = whenAny(futures.begin(), futures.end());
+ auto anyf = collectAny(futures.begin(), futures.end());
EXPECT_FALSE(anyf.isReady());
for (auto& p : promises)
futures.push_back(p.getFuture());
- auto anyf = whenAny(futures.begin(), futures.end())
+ auto anyf = collectAny(futures.begin(), futures.end())
.then([](pair<size_t, Try<int>> p) {
EXPECT_EQ(42, p.second.value());
});
for (int i = 0; i < 10; i++)
fs.push_back(makeFuture());
- whenAll(fs.begin(), fs.end())
+ collectAll(fs.begin(), fs.end())
.then([&](vector<Try<void>> ts) {
EXPECT_EQ(fs.size(), ts.size());
});
for (int i = 0; i < 10; i++)
fs.push_back(makeFuture(i));
- whenAny(fs.begin(), fs.end())
+ collectAny(fs.begin(), fs.end())
.then([&](pair<size_t, Try<int>> p) {
EXPECT_EQ(p.first, p.second.value());
});
}
}
-TEST(when, whenN) {
+TEST(when, collectN) {
vector<Promise<void>> promises(10);
vector<Future<void>> futures;
bool flag = false;
size_t n = 3;
- whenN(futures.begin(), futures.end(), n)
+ collectN(futures.begin(), futures.end(), n)
.then([&](vector<pair<size_t, Try<void>>> v) {
flag = true;
EXPECT_EQ(n, v.size());
for (int i = 0; i < 10; i++)
futures.push_back(makeFuture());
- auto anyf = whenAny(futures.begin(), futures.end());
+ auto anyf = collectAny(futures.begin(), futures.end());
}
{
for (int i = 0; i < 10; i++)
futures.push_back(makeFuture());
- auto allf = whenAll(futures.begin(), futures.end());
+ auto allf = collectAll(futures.begin(), futures.end());
}
}
-TEST(Future, whenAllVariadic) {
+TEST(Future, collectAllVariadic) {
Promise<bool> pb;
Promise<int> pi;
Future<bool> fb = pb.getFuture();
Future<int> fi = pi.getFuture();
bool flag = false;
- whenAll(std::move(fb), std::move(fi))
+ collectAll(std::move(fb), std::move(fi))
.then([&](std::tuple<Try<bool>, Try<int>> tup) {
flag = true;
EXPECT_TRUE(std::get<0>(tup).hasValue());
EXPECT_TRUE(flag);
}
-TEST(Future, whenAllVariadicReferences) {
+TEST(Future, collectAllVariadicReferences) {
Promise<bool> pb;
Promise<int> pi;
Future<bool> fb = pb.getFuture();
Future<int> fi = pi.getFuture();
bool flag = false;
- whenAll(fb, fi)
+ collectAll(fb, fi)
.then([&](std::tuple<Try<bool>, Try<int>> tup) {
flag = true;
EXPECT_TRUE(std::get<0>(tup).hasValue());
EXPECT_TRUE(flag);
}
-TEST(Future, whenAll_none) {
+TEST(Future, collectAll_none) {
vector<Future<int>> fs;
- auto f = whenAll(fs.begin(), fs.end());
+ auto f = collectAll(fs.begin(), fs.end());
EXPECT_TRUE(f.isReady());
}
vector<Future<void>> v_f;
v_f.push_back(makeFuture());
v_f.push_back(makeFuture());
- auto done_v_f = whenAll(v_f.begin(), v_f.end()).wait().value();
+ auto done_v_f = collectAll(v_f.begin(), v_f.end()).wait().value();
EXPECT_EQ(2, done_v_f.size());
vector<Future<bool>> v_fb;
v_fb.push_back(makeFuture(true));
v_fb.push_back(makeFuture(false));
- auto fut = whenAll(v_fb.begin(), v_fb.end());
+ auto fut = collectAll(v_fb.begin(), v_fb.end());
auto done_v_fb = std::move(fut.wait().value());
EXPECT_EQ(2, done_v_fb.size());
}
vector<Future<bool>> v_fb;
v_fb.push_back(makeFuture(true));
v_fb.push_back(makeFuture(false));
- auto f = whenAll(v_fb.begin(), v_fb.end());
+ auto f = collectAll(v_fb.begin(), v_fb.end());
f.wait(milliseconds(1));
EXPECT_TRUE(f.isReady());
EXPECT_EQ(2, f.value().size());
Promise<bool> p2;
v_fb.push_back(p1.getFuture());
v_fb.push_back(p2.getFuture());
- auto f = whenAll(v_fb.begin(), v_fb.end());
+ auto f = collectAll(v_fb.begin(), v_fb.end());
f.wait(milliseconds(1));
EXPECT_FALSE(f.isReady());
p1.setValue(true);
for (auto& p : *promises) p.setValue();
});
- return whenAll(futures.begin(), futures.end());
+ return collectAll(futures.begin(), futures.end());
};
fn().wait();
projects / folly.git / commitdiff