You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by be...@apache.org on 2012/09/18 02:27:32 UTC
svn commit: r1386929 -
/incubator/mesos/trunk/third_party/libprocess/include/process/async.hpp
Author: benh
Date: Tue Sep 18 00:27:32 2012
New Revision: 1386929
URL: http://svn.apache.org/viewvc?rev=1386929&view=rev
Log:
Added missing process/async.hpp.
Added:
incubator/mesos/trunk/third_party/libprocess/include/process/async.hpp
Added: incubator/mesos/trunk/third_party/libprocess/include/process/async.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/third_party/libprocess/include/process/async.hpp?rev=1386929&view=auto
==============================================================================
--- incubator/mesos/trunk/third_party/libprocess/include/process/async.hpp (added)
+++ incubator/mesos/trunk/third_party/libprocess/include/process/async.hpp Tue Sep 18 00:27:32 2012
@@ -0,0 +1,231 @@
+#ifndef __ASYNC_HPP__
+#define __ASYNC_HPP__
+
+#include <process/dispatch.hpp>
+#include <process/future.hpp>
+#include <process/id.hpp>
+#include <process/process.hpp>
+
+#include <tr1/functional>
+
+namespace process {
+
+// TODO(vinod): Merge this into ExecutorProcess.
+// TODO(vinod): Add support for void functions. Currently this is tricky,
+// because Future<void> is not supported.
+class AsyncExecutorProcess : public Process<AsyncExecutorProcess>
+{
+private:
+ friend class AsyncExecutor;
+
+ AsyncExecutorProcess() : ProcessBase(ID::generate("__async_executor__")) {}
+ virtual ~AsyncExecutorProcess() {}
+
+ // Not copyable, not assignable.
+ AsyncExecutorProcess(const AsyncExecutorProcess&);
+ AsyncExecutorProcess& operator = (const AsyncExecutorProcess&);
+
+ template<typename F>
+ typename std::tr1::result_of<F(void)>::type execute(
+ const F& f)
+ {
+ terminate(self()); // Terminate this process after the function returns.
+ return f();
+ }
+
+ // TODO(vinod): Use boost macro enumerations.
+ template<typename F, typename A1>
+ typename std::tr1::result_of<F(A1)>::type execute(
+ const F& f, A1 a1)
+ {
+ terminate(self()); // Terminate this process after the function returns.
+ return f(a1);
+ }
+
+ template<typename F, typename A1, typename A2>
+ typename std::tr1::result_of<F(A1, A2)>::type execute(
+ const F& f, A1 a1, A2 a2)
+ {
+ terminate(self()); // Terminate this process after the function returns.
+ return f(a1, a2);
+ }
+
+ template<typename F, typename A1, typename A2, typename A3>
+ typename std::tr1::result_of<F(A1, A2, A3)>::type execute(
+ const F& f, A1 a1, A2 a2, A3 a3)
+ {
+ terminate(self()); // Terminate this process after the function returns.
+ return f(a1, a2, a3);
+ }
+
+ template<typename F, typename A1, typename A2, typename A3, typename A4>
+ typename std::tr1::result_of<F(A1, A2, A3, A4)>::type execute(
+ const F& f, A1 a1, A2 a2, A3 a3, A4 a4)
+ {
+ terminate(self()); // Terminate this process after the function returns.
+ return f(a1, a2, a3, a4);
+ }
+};
+
+
+// This is a wrapper around AsyncExecutorProcess.
+class AsyncExecutor
+{
+private:
+ // Declare async functions as friends.
+ template<typename F>
+ friend Future<typename std::tr1::result_of<F(void)>::type> async(
+ const F& f);
+
+ template<typename F, typename A1>
+ friend Future<typename std::tr1::result_of<F(A1)>::type> async(
+ const F& f, A1 a1);
+
+ template<typename F, typename A1, typename A2>
+ friend Future<typename std::tr1::result_of<F(A1, A2)>::type> async(
+ const F& f, A1 a1, A2 a2);
+
+ template<typename F, typename A1, typename A2, typename A3>
+ friend Future<typename std::tr1::result_of<F(A1, A2, A3)>::type> async(
+ const F& f, A1 a1, A2 a2, A3 a3);
+
+ template<typename F, typename A1, typename A2, typename A3, typename A4>
+ friend Future<typename std::tr1::result_of<F(A1, A2, A3, A4)>::type> async(
+ const F& f, A1 a1, A2 a2, A3 a3, A4 a4);
+
+ AsyncExecutor()
+ {
+ process = new AsyncExecutorProcess();
+ spawn(process, true); // Automatically GC.
+ }
+
+ virtual ~AsyncExecutor() {}
+
+ // Not copyable, not assignable.
+ AsyncExecutor(const AsyncExecutor&);
+ AsyncExecutor& operator = (const AsyncExecutor&);
+
+ template<typename F>
+ Future<typename std::tr1::result_of<F(void)>::type> execute(
+ const F& f)
+ {
+ // Necessary to disambiguate.
+ typedef typename std::tr1::result_of<F(void)>::type
+ (AsyncExecutorProcess::*R)(const F&);
+
+ return dispatch(process,
+ static_cast<R>(&AsyncExecutorProcess::execute),
+ f);
+ }
+
+ // TODO(vinod): Use boost macro enumerations.
+ template<typename F, typename A1>
+ Future<typename std::tr1::result_of<F(A1)>::type> execute(
+ const F& f, A1 a1)
+ {
+ // Necessary to disambiguate.
+ typedef typename std::tr1::result_of<F(A1)>::type
+ (AsyncExecutorProcess::*R)(const F&, A1);
+
+ return dispatch(process,
+ static_cast<R>(&AsyncExecutorProcess::execute),
+ f,
+ a1);
+ }
+
+ template<typename F, typename A1, typename A2>
+ Future<typename std::tr1::result_of<F(A1, A2)>::type> execute(
+ const F& f, A1 a1, A2 a2)
+ {
+ // Necessary to disambiguate.
+ typedef typename std::tr1::result_of<F(A1, A2)>::type
+ (AsyncExecutorProcess::*R)(const F&, A1, A2);
+
+ return dispatch(process,
+ static_cast<R>(&AsyncExecutorProcess::execute),
+ f,
+ a1,
+ a2);
+ }
+
+ template<typename F, typename A1, typename A2, typename A3>
+ Future<typename std::tr1::result_of<F(A1, A2, A3)>::type> execute(
+ const F& f, A1 a1, A2 a2, A3 a3)
+ {
+ // Necessary to disambiguate.
+ typedef typename std::tr1::result_of<F(A1, A2, A3)>::type
+ (AsyncExecutorProcess::*R)(const F&, A1, A2, A3);
+
+ return dispatch(process,
+ static_cast<R>(&AsyncExecutorProcess::execute),
+ f,
+ a1,
+ a2,
+ a3);
+ }
+
+ template<typename F, typename A1, typename A2, typename A3, typename A4>
+ Future<typename std::tr1::result_of<F(A1, A2, A3, A4)>::type> execute(
+ const F& f, A1 a1, A2 a2, A3 a3, A4 a4)
+ {
+ // Necessary to disambiguate.
+ typedef typename std::tr1::result_of<F(A1, A2, A3, A4)>::type
+ (AsyncExecutorProcess::*R)(const F&, A1, A2, A3, A4);
+
+ return dispatch(process,
+ static_cast<R>(&AsyncExecutorProcess::execute),
+ f,
+ a1,
+ a2,
+ a3,
+ a4);
+ }
+
+ AsyncExecutorProcess* process;
+};
+
+
+// Provides an abstraction for asynchronously executing a function.
+// TODO(vinod): Use boost macro to enumerate arguments/params.
+template<typename F>
+Future<typename std::tr1::result_of<F(void)>::type>
+ async(const F& f)
+{
+ return AsyncExecutor().execute(f);
+}
+
+
+template<typename F, typename A1>
+Future<typename std::tr1::result_of<F(A1)>::type>
+ async(const F& f, A1 a1)
+{
+ return AsyncExecutor().execute(f, a1);
+}
+
+
+template<typename F, typename A1, typename A2>
+Future<typename std::tr1::result_of<F(A1, A2)>::type>
+ async(const F& f, A1 a1, A2 a2)
+{
+ return AsyncExecutor().execute(f, a1, a2);
+}
+
+
+template<typename F, typename A1, typename A2, typename A3>
+Future<typename std::tr1::result_of<F(A1, A2, A3)>::type>
+ async(const F& f, A1 a1, A2 a2, A3 a3)
+{
+ return AsyncExecutor().execute(f, a1, a2, a3);
+}
+
+
+template<typename F, typename A1, typename A2, typename A3, typename A4>
+Future<typename std::tr1::result_of<F(A1, A2, A3, A4)>::type>
+ async(const F& f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+ return AsyncExecutor().execute(f, a1, a2, a3, a4);
+}
+
+} // namespace process {
+
+#endif __ASYNC_HPP__