/// Futures you will pay no Timekeeper thread overhead.
Future<void> sleep(Duration, Timekeeper* = nullptr);
- /// Create a Future chain from a sequence of callbacks. i.e.
- ///
- /// f.then(a).then(b).then(c);
- ///
- /// where f is a Future<A> and the result of the chain is a Future<Z>
- /// becomes
- ///
- /// f.then(chain<A,Z>(a, b, c));
- // If anyone figures how to get chain to deduce A and Z, I'll buy you a drink.
- template <class A, class Z, class... Callbacks>
- std::function<Future<Z>(Try<A>)>
- chain(Callbacks... fns);
-
/**
* Set func as the callback for each input Future and return a vector of
* Futures containing the results in the input order.
return map(c.begin(), c.end(), std::forward<F>(func));
}
-}
+} // namespace futures
/**
Make a completed Future by moving in a value. e.g.
* This is just syntactic sugar for makeFuture().via(executor)
*
* @param executor the Executor to call back on
+ * @param priority optionally, the priority to add with. Defaults to 0 which
+ * represents medium priority.
*
* @returns a void Future that will call back on the given executor
*/
-template <typename Executor>
-Future<void> via(Executor* executor);
+inline Future<void> via(
+ Executor* executor,
+ int8_t priority = Executor::MID_PRI);
+
+/// Execute a function via the given executor and return a future.
+/// This is semantically equivalent to via(executor).then(func), but
+/// easier to read and slightly more efficient.
+template <class Func>
+auto via(Executor*, Func func)
+ -> Future<typename isFuture<decltype(func())>::Inner>;
/** When all the input Futures complete, the returned Future will complete.
Errors do not cause early termination; this Future will always succeed
/// is a Future<std::tuple<Try<T1>, Try<T2>, ...>>.
/// The Futures are moved in, so your copies are invalid.
template <typename... Fs>
-typename detail::VariadicContext<
+typename detail::CollectAllVariadicContext<
typename std::decay<Fs>::type::value_type...>::type
collectAll(Fs&&... fs);
return collect(c.begin(), c.end());
}
+/// Like collectAll, but will short circuit on the first exception. Thus, the
+/// type of the returned Future is std::tuple<T1, T2, ...> instead of
+/// std::tuple<Try<T1>, Try<T2>, ...>
+template <typename... Fs>
+typename detail::CollectVariadicContext<
+ typename std::decay<Fs>::type::value_type...>::type
+collect(Fs&&... fs);
+
/** The result is a pair of the index of the first Future to complete and
the Try. If multiple Futures complete at the same time (or are already
complete when passed in), the "winner" is chosen non-deterministically.
return collectN(c.begin(), c.end(), n);
}
+/** window creates up to n Futures using the values
+ in the collection, and then another Future for each Future
+ that completes
+
+ this is basically a sliding window of Futures of size n
+
+ func must return a Future for each value in input
+ */
+template <class Collection, class F,
+ class ItT = typename std::iterator_traits<
+ typename Collection::iterator>::value_type,
+ class Result = typename detail::resultOf<F, ItT&&>::value_type>
+std::vector<Future<Result>>
+window(Collection input, F func, size_t n);
+
template <typename F, typename T, typename ItT>
using MaybeTryArg = typename std::conditional<
detail::callableWith<F, T&&, Try<ItT>&&>::value, Try<ItT>, ItT>::type;
The type of the final result is a Future of the type of the initial value.
Func can either return a T, or a Future<T>
+
+ func is called in order of the input, see unorderedReduce if that is not
+ a requirement
*/
-template <class It, class T, class F,
- class ItT = typename std::iterator_traits<It>::value_type::value_type,
- class Arg = MaybeTryArg<F, T, ItT>>
-typename std::enable_if<!isFutureResult<F, T, Arg>::value, Future<T>>::type
-reduce(It first, It last, T initial, F func);
+template <class It, class T, class F>
+Future<T> reduce(It first, It last, T&& initial, F&& func);
+/// Sugar for the most common case
+template <class Collection, class T, class F>
+auto reduce(Collection&& c, T&& initial, F&& func)
+ -> decltype(reduce(c.begin(), c.end(), std::forward<T>(initial),
+ std::forward<F>(func))) {
+ return reduce(
+ c.begin(),
+ c.end(),
+ std::forward<T>(initial),
+ std::forward<F>(func));
+}
+
+/** like reduce, but calls func on finished futures as they complete
+ does NOT keep the order of the input
+ */
template <class It, class T, class F,
class ItT = typename std::iterator_traits<It>::value_type::value_type,
class Arg = MaybeTryArg<F, T, ItT>>
-typename std::enable_if<isFutureResult<F, T, Arg>::value, Future<T>>::type
-reduce(It first, It last, T initial, F func);
+Future<T> unorderedReduce(It first, It last, T initial, F func);
/// Sugar for the most common case
template <class Collection, class T, class F>
-auto reduce(Collection&& c, T&& initial, F&& func)
- -> decltype(reduce(c.begin(), c.end(), initial, func)) {
- return reduce(
+auto unorderedReduce(Collection&& c, T&& initial, F&& func)
+ -> decltype(unorderedReduce(c.begin(), c.end(), std::forward<T>(initial),
+ std::forward<F>(func))) {
+ return unorderedReduce(
c.begin(),
c.end(),
std::forward<T>(initial),
std::forward<F>(func));
}
-} // namespace folly
+} // namespace
projects / folly.git / blobdiff