From f25d7ac068927133eedfb5805c2491e8973cd93d Mon Sep 17 00:00:00 2001
From: Tomasz Grabiec <tgrabiec@cloudius-systems.com>
Date: Fri, 6 Mar 2015 10:01:25 +0100
Subject: [PATCH] core: Add futurize::apply()

Invokes given function wrapping the result in a future if necessary.
---
 core/future.hh | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/core/future.hh b/core/future.hh
index 25ee4a1287..8f92915097 100644
--- a/core/future.hh
+++ b/core/future.hh
@@ -363,18 +363,36 @@ template <typename T>
 struct futurize {
     using type = future<T>;
     using promise_type = promise<T>;
+
+    template<typename Func, typename... FuncArgs>
+    static inline type apply(Func&& func, std::tuple<FuncArgs...>&& args);
+
+    template<typename Func, typename... FuncArgs>
+    static inline type apply(Func&& func, FuncArgs&&... args);
 };
 
 template <>
 struct futurize<void> {
     using type = future<>;
     using promise_type = promise<>;
+
+    template<typename Func, typename... FuncArgs>
+    static inline type apply(Func&& func, std::tuple<FuncArgs...>&& args);
+
+    template<typename Func, typename... FuncArgs>
+    static inline type apply(Func&& func, FuncArgs&&... args);
 };
 
 template <typename... Args>
 struct futurize<future<Args...>> {
     using type = future<Args...>;
     using promise_type = promise<Args...>;
+
+    template<typename Func, typename... FuncArgs>
+    static inline type apply(Func&& func, std::tuple<FuncArgs...>&& args);
+
+    template<typename Func, typename... FuncArgs>
+    static inline type apply(Func&& func, FuncArgs&&... args);
 };
 
 // Converts a type to a future type, if it isn't already.
@@ -721,4 +739,40 @@ future<T...> make_exception_future(Exception&& ex) noexcept {
     return make_exception_future<T...>(std::make_exception_ptr(std::forward<Exception>(ex)));
 }
 
+template<typename T>
+template<typename Func, typename... FuncArgs>
+typename futurize<T>::type futurize<T>::apply(Func&& func, std::tuple<FuncArgs...>&& args) {
+    return make_ready_future<T>(::apply(std::forward<Func>(func), std::move(args)));
+}
+
+template<typename T>
+template<typename Func, typename... FuncArgs>
+typename futurize<T>::type futurize<T>::apply(Func&& func, FuncArgs&&... args) {
+    return make_ready_future<T>(func(std::forward<FuncArgs>(args)...));
+}
+
+template<typename Func, typename... FuncArgs>
+typename futurize<void>::type futurize<void>::apply(Func&& func, std::tuple<FuncArgs...>&& args) {
+    ::apply(std::forward<Func>(func), std::move(args));
+    return make_ready_future<>();
+}
+
+template<typename Func, typename... FuncArgs>
+typename futurize<void>::type futurize<void>::apply(Func&& func, FuncArgs&&... args) {
+    func(std::forward<FuncArgs>(args)...);
+    return make_ready_future<>();
+}
+
+template<typename... Args>
+template<typename Func, typename... FuncArgs>
+typename futurize<future<Args...>>::type futurize<future<Args...>>::apply(Func&& func, std::tuple<FuncArgs...>&& args) {
+    return ::apply(std::forward<Func>(func), std::move(args));
+}
+
+template<typename... Args>
+template<typename Func, typename... FuncArgs>
+typename futurize<future<Args...>>::type futurize<future<Args...>>::apply(Func&& func, FuncArgs&&... args) {
+    return func(std::forward<FuncArgs>(args)...);
+}
+
 #endif /* FUTURE_HH_ */