deferred.hpp File Reference

#include <functional>
#include <process/dispatch.hpp>
#include <process/pid.hpp>
#include <stout/preprocessor.hpp>

Go to the source code of this file.

Classes
struct	process::Deferred< F >
struct	process::_Deferred< F >

Namespaces
	process

Macros
#define	PLACEHOLDER(Z, N, DATA)   CAT(lambda::_, INC(N))
#define	FORWARD(Z, N, DATA)   std::forward<P ## N>(p ## N)
#define	TEMPLATE(Z, N, DATA)
#define	TEMPLATE(Z, N, DATA)
#define	FORWARD(Z, N, DATA)   std::forward<A ## N>(a ## N)
#define	TEMPLATE(Z, N, DATA)
#define	TEMPLATE(Z, N, DATA)
#define	TEMPLATE(Z, N, DATA)

Macro Definition Documentation

#define FORWARD	(		Z,
			N,
			DATA
	)		std::forward<P ## N>(p ## N)

#define FORWARD	(		Z,
			N,
			DATA
	)		std::forward<A ## N>(a ## N)

#define PLACEHOLDER	(		Z,
			N,
			DATA
	)		CAT(lambda::_, INC(N))

#define TEMPLATE	(		Z,
			N,
			DATA
	)

#define TEMPLATE	(		Z,
			N,
			DATA
	)

#define TEMPLATE	(		Z,
			N,
			DATA
	)

Value:

template <typename T,                                                  \
            ENUM_PARAMS(N, typename P),                                  \
            ENUM_PARAMS(N, typename A)>                                  \
  friend auto defer(const PID<T>& pid,                                   \
                    void (T::*method)(ENUM_PARAMS(N, P)),                \
                    ENUM_BINARY_PARAMS(N, A, &&a))                       \
    -> _Deferred<decltype(                                               \
           lambda::partial(                                              \
               &std::function<void(ENUM_PARAMS(N, P))>::operator(),      \
               std::function<void(ENUM_PARAMS(N, P))>(),                 \
               ENUM(N, FORWARD, _)))>;

#define TEMPLATE	(		Z,
			N,
			DATA
	)

Value:

template <typename R,                                                  \
            typename T,                                                  \
            ENUM_PARAMS(N, typename P),                                  \
            ENUM_PARAMS(N, typename A)>                                  \
  friend auto defer(const PID<T>& pid,                                   \
                    Future<R> (T::*method)(ENUM_PARAMS(N, P)),           \
                    ENUM_BINARY_PARAMS(N, A, &&a))                       \
    -> _Deferred<decltype(                                               \
           lambda::partial(                                              \
               &std::function<Future<R>(ENUM_PARAMS(N, P))>::operator(), \
               std::function<Future<R>(ENUM_PARAMS(N, P))>(),            \
               ENUM(N, FORWARD, _)))>;

#define TEMPLATE	(		Z,
			N,
			DATA
	)

Value:

template <typename R,                                                  \
            typename T,                                                  \
            ENUM_PARAMS(N, typename P),                                  \
            ENUM_PARAMS(N, typename A)>                                  \
  friend auto defer(const PID<T>& pid,                                   \
                    R (T::*method)(ENUM_PARAMS(N, P)),                   \
                    ENUM_BINARY_PARAMS(N, A, &&a))                       \
    -> _Deferred<decltype(                                               \
         lambda::partial(                                                \
           &std::function<Future<R>(ENUM_PARAMS(N, P))>::operator(),     \
           std::function<Future<R>(ENUM_PARAMS(N, P))>(),                \
           ENUM(N, FORWARD, _)))>;