CAmSerializer.h

Go to the documentation of this file.

#ifndef CAMSERIALIZER_H_
#define CAMSERIALIZER_H_

#include <deque>
#include <cassert>
#include <memory>
#include <stdexcept>
#include <unistd.h>
#include "CAmDltWrapper.h"
#include "CAmSocketHandler.h"

template<std::size_t ... Is>
struct indices
{
};

template<std::size_t N, std::size_t ... Is>
struct build_indices: build_indices<N - 1, N - 1, Is...>
{
};

template<std::size_t ... Is>
struct build_indices<0, Is...> : indices<Is...>
{
};

template<int I> struct placeholder
{
};

namespace std
{
    template<int I>
    struct is_placeholder<::placeholder<I>> : std::integral_constant<int, I>
    {
    };
}

#if defined(__GNUC__)
# define DEPRECATED(MSG) __attribute__ ((__deprecated__((#MSG))))
#else
# define DEPRECATED(MSG)
#endif

namespace am
{
    namespace V1
    {
        class CAmSerializer
        {
        private:

            class CAmDelegate
            {
            public:

                typedef enum
                    :bool
                    {
                        SyncCallType = false, AsyncCallType = true
                } CallType;

                virtual ~CAmDelegate()
                {
                }
                ;
                virtual CallType call(int* pipe)=0;

            };

            template<class Class, typename Method, typename Tuple, bool Done, int Total, int ... N>
            class CAmDelegateAsyncImpl: public CAmDelegate
            {
                Class mInstance;
                Method mMethod;
                Tuple mArguments;
            public:
                friend class CAmSerializer;
                static void call(Class instance, Method method, Tuple && arguments)
                {
                    CAmDelegateAsyncImpl<Class, Method, Tuple, Total == 1 + sizeof...(N), Total, N..., sizeof...(N)>::call(instance, method, std::forward<Tuple>(arguments));
                }

                CAmDelegateAsyncImpl(Class instance, Method method, Tuple && arguments)
                {
                    mInstance = instance;
                    mMethod = method;
                    mArguments = std::move(arguments);
                }

                CallType call(int* pipe)
                {
                    (void) pipe;
                    call(mInstance, mMethod, std::forward<Tuple>(mArguments));
                    return (AsyncCallType);
                }
                ;
            };

            template<class Class, typename Method, typename Tuple, int Total, int ... N>
            class CAmDelegateAsyncImpl<Class, Method, Tuple, true, Total, N...> : public CAmDelegate
            {
                Class mInstance;
                Method mMethod;
                Tuple mArguments;
            public:
                friend class CAmSerializer;
                static void call(Class instance, Method method, Tuple && t)
                {
                    (*instance.*method)(std::get<N>(std::forward<Tuple>(t))...);
                }

                CAmDelegateAsyncImpl(Class instance, Method method, Tuple && arguments)
                {
                    mInstance = instance;
                    mMethod = method;
                    mArguments = std::move(arguments);
                }

                CallType call(int* pipe)
                {
                    (void) pipe;
                    call(mInstance, mMethod, std::forward<Tuple>(mArguments));
                    return (AsyncCallType);
                }
                ;
            };

            template<class Class, typename Method, typename Return, typename Tuple, bool Done, int Total, int ... N>
            class CAmDelegateSyncImpl: public CAmDelegate
            {
                Class mInstance;
                Method mMethod;
                Tuple mArguments;
                Return mReturn;
            public:
                friend class CAmSerializer;
                static void call(Class instance, Method method, Return & result, Tuple && arguments)
                {
                    CAmDelegateSyncImpl<Class, Method, Return, Tuple, Total == 1 + sizeof...(N), Total, N..., sizeof...(N)>::call(instance, method, result, std::forward<Tuple>(arguments));
                }

                CAmDelegateSyncImpl(Class instance, Method method, Tuple && arguments)
                {
                    mInstance = instance;
                    mMethod = method;
                    mArguments = std::move(arguments);
                }

                CallType call(int* pipe)
                {
                    call(mInstance, mMethod, mReturn, std::forward<Tuple>(mArguments));
                    ssize_t result(-1);
                    result = write(pipe[1], this, sizeof(this));
                    if (result == -1)
                        logError("CAmSerializer: Problem writing into pipe! Error No:", errno);
                    return (SyncCallType);
                }
                ;
            };

            template<class Class, typename Method, typename Return, typename Tuple, int Total, int ... N>
            class CAmDelegateSyncImpl<Class, Method, Return, Tuple, true, Total, N...> : public CAmDelegate
            {
                Class mInstance;
                Method mMethod;
                Tuple mArguments;
                Return mReturn;
            public:
                friend class CAmSerializer;
                static void call(Class instance, Method method, Return & result, Tuple && t)
                {
                    result = (*instance.*method)(std::get<N>(t)...);
                }

                CAmDelegateSyncImpl(Class instance, Method method, Tuple && arguments)
                {
                    mInstance = instance;
                    mMethod = method;
                    mArguments = std::move(arguments);
                }

                CallType call(int* pipe)
                {
                    call(mInstance, mMethod, mReturn, std::forward<Tuple>(mArguments));
                    ssize_t result(-1);
                    result = write(pipe[1], this, sizeof(this));
                    if (result == -1)
                        logError("CAmSerializer: Problem writing into pipe! Error No:", errno);
                    return (SyncCallType);
                }
                ;
            };

            typedef CAmDelegate* CAmDelegagePtr; 

        public:
            template<typename Class, typename Method, typename Tuple>
            void doAsyncCall(Class intsance, Method method, Tuple & arguments)
            {
                typedef typename std::decay<Tuple>::type ttype;
                typedef CAmDelegateAsyncImpl<Class, Method, Tuple, 0 == std::tuple_size<ttype>::value, std::tuple_size<ttype>::value> AsyncDelegate;
                AsyncDelegate *pImp = new AsyncDelegate(intsance, method, std::forward<Tuple>(arguments));
                send(pImp);
                //Do not delete the pointer. It will be deleted automatically later.
            }

            template<typename Class, typename Method, typename Return, typename Tuple>
            void doSyncCall(Class intsance, Method method, Return & result, Tuple & arguments)
            {
                typedef typename std::decay<Tuple>::type ttype;
                typedef CAmDelegateSyncImpl<Class, Method, Return, Tuple, 0 == std::tuple_size<ttype>::value, std::tuple_size<ttype>::value> SyncDelegate;
                SyncDelegate *pImp = new SyncDelegate(intsance, method, std::forward<Tuple>(arguments));
                send(pImp);
                int numReads;
                SyncDelegate *p = NULL;
                if ((numReads = read(mReturnPipe[0], &p, sizeof(p))) == -1)
                {
                    logError("CAmSerializer::doSyncCall could not read pipe!");
                    throw std::runtime_error("CAmSerializer Could not read pipe!");
                }
                result = std::move(pImp->mReturn);
                arguments = std::move(pImp->mArguments);
                //Delete the pointer.
                delete pImp;
            }
        private:

            inline void send(CAmDelegagePtr p)
            {
                if (write(mPipe[1], &p, sizeof(p)) == -1)
                {
                    throw std::runtime_error("could not write to pipe !");
                }
            }

            int mPipe[2]; 
            int mReturnPipe[2]; 
            sh_pollHandle_t mHandle;
            CAmSocketHandler* mpSocketHandler;
            std::deque<CAmDelegagePtr> mListDelegatePoiters; 

        public:

            int getListDelegatePoiters()
            {
                return mListDelegatePoiters.size();
            }

            template<class TClass, class TRet, class ... TArgs>
            void syncCall(TClass* instance, TRet (TClass::*method)(TArgs ...), TRet & result, TArgs & ... arguments)
            {
                auto t = std::make_tuple(arguments...);
                doSyncCall(instance, method, result, t);
                std::tie(arguments...) = t;
            }

            template<class TClass, class TRet, class ... TArgs>
            void asyncCall(TClass* instance, TRet (TClass::*method)(TArgs ...), TArgs & ... arguments)
            {
                auto t = std::make_tuple(arguments...);
                doAsyncCall(instance, method, t);
            }

            template<class TClass>
            void asyncCall(TClass* instance, void (TClass::*function)())
            {
                auto t = std::make_tuple();
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ), Targ argument)
            {
                auto t = std::make_tuple(argument);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ&), Targ& argument)
            {
                auto t = std::make_tuple(argument);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1)
            {
                auto t = std::make_tuple(argument, argument1);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ& argument, Targ1 argument1), Targ& argument, Targ1 argument1)
            {
                auto t = std::make_tuple(argument, argument1);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1& argument1), Targ argument, Targ1& argument1)
            {
                auto t = std::make_tuple(argument, argument1);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ& argument, Targ1& argument1), Targ& argument, Targ1& argument1)
            {
                auto t = std::make_tuple(argument, argument1);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ& argument, Targ1 argument1, Targ2 argument2), Targ& argument, Targ1 argument1, Targ2 argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1& argument1, Targ2 argument2), Targ argument, Targ1& argument1, Targ2 argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1, Targ2& argument2), Targ argument, Targ1 argument1, Targ2& argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1& argument1, Targ2& argument2), Targ argument, Targ1& argument1, Targ2& argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ& argument, Targ1& argument1, Targ2& argument2), Targ& argument, Targ1& argument1, Targ2& argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ& argument, Targ1& argument1, Targ2 argument2), Targ& argument, Targ1& argument1, Targ2 argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ& argument, Targ1 argument1, Targ2& argument2), Targ& argument, Targ1 argument1, Targ2& argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class Targ, class Targ1, class Targ2, class Targ3>
            void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3)
            {
                auto t = std::make_tuple(argument, argument1, argument2, argument3);
                doAsyncCall(instance, function, t);
            }

            template<class TClass1, class TretVal>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(), TretVal& retVal)
            {
                auto t = std::make_tuple();
                doSyncCall(instance, function, retVal, t);
            }

            template<class TClass1, class TretVal, class TargCall, class Targ>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall), TretVal& retVal, Targ& argument)
            {
                auto t = std::make_tuple(argument);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument) = t;
            }

            template<class TClass1, class TretVal, class TargCall, class Targ>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall) const, TretVal& retVal, Targ& argument)
            {
                auto t = std::make_tuple(argument);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument) = t;
            }

            template<class TClass1, class TretVal, class TargCall, class Targ1Call, class Targ, class Targ1>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, Targ1Call), TretVal& retVal, Targ& argument, Targ1& argument1)
            {
                auto t = std::make_tuple(argument, argument1);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument, argument1) = t;
            }
            template<class TClass1, class TretVal, class TargCall, class Targ1Call, class Targ, class Targ1>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, Targ1Call) const, TretVal& retVal, Targ& argument, Targ1& argument1)
            {
                auto t = std::make_tuple(argument, argument1);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument, argument1) = t;
            }

            template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class Targ, class Targ1, class Targ2>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument, argument1, argument2) = t;
            }

            template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class Targ, class Targ1, class Targ2>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2) const, TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2)
            {
                auto t = std::make_tuple(argument, argument1, argument2);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument, argument1, argument2) = t;
            }

            template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class TargCall3, class Targ, class Targ1, class Targ2, class Targ3>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3)
            {
                auto t = std::make_tuple(argument, argument1, argument2, argument3);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument, argument1, argument2, argument3) = t;
            }

            template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class TargCall3, class TargCall4, class Targ, class Targ1, class Targ2, class Targ3, class Targ4>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4)
            {
                auto t = std::make_tuple(argument, argument1, argument2, argument3, argument4);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument, argument1, argument2, argument3, argument4) = t;
            }

            template<class TClass1, class TretVal, class TargCall, class TargCall1, class TargCall2, class TargCall3, class TargCall4, class TargCall5, class Targ, class Targ1, class Targ2, class Targ3, class Targ4, class Targ5>
            void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4, TargCall5), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3,
                    Targ4& argument4, Targ5& argument5)
            {
                auto t = std::make_tuple(argument, argument1, argument2, argument3, argument4, argument5);
                doSyncCall(instance, function, retVal, t);
                std::tie(argument, argument1, argument2, argument3, argument4, argument5) = t;
            }

            void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData)
            {
                (void) handle;
                (void) userData;
                int numReads;
                CAmDelegagePtr listPointers[3];
                if ((numReads = read(pollfd.fd, &listPointers, sizeof(listPointers))) == -1)
                {
                    logError("CAmSerializer::receiverCallback could not read pipe!");
                    throw std::runtime_error("CAmSerializer Could not read pipe!");
                }
                mListDelegatePoiters.assign(listPointers, listPointers + (numReads / sizeof(CAmDelegagePtr)));
            }

            bool checkerCallback(const sh_pollHandle_t handle, void* userData)
            {
                (void) handle;
                (void) userData;
                if (mListDelegatePoiters.empty())
                    return (false);
                return (true);
            }

            bool dispatcherCallback(const sh_pollHandle_t handle, void* userData)
            {
                (void) handle;
                (void) userData;
                CAmDelegagePtr delegatePoiter = mListDelegatePoiters.front();
                mListDelegatePoiters.pop_front();
                if (delegatePoiter->call(mReturnPipe))
                    delete delegatePoiter;
                if (mListDelegatePoiters.empty())
                    return (false);
                return (true);
            }

            TAmShPollFired<CAmSerializer> receiverCallbackT;
            TAmShPollDispatch<CAmSerializer> dispatcherCallbackT;
            TAmShPollCheck<CAmSerializer> checkerCallbackT;

            CAmSerializer(CAmSocketHandler *iSocketHandler) :
                    mPipe(), //
                            mReturnPipe(), //
                            mHandle(),
                            mpSocketHandler(iSocketHandler),
                            mListDelegatePoiters(), //
                            receiverCallbackT(this, &CAmSerializer::receiverCallback), //
                            dispatcherCallbackT(this, &CAmSerializer::dispatcherCallback), //
                            checkerCallbackT(this, &CAmSerializer::checkerCallback)
            {
                assert(NULL!=iSocketHandler);

                if (pipe(mPipe) == -1)
                {
                    logError("CAmSerializer could not create pipe!");
                    throw std::runtime_error("CAmSerializer Could not open pipe!");
                }

                if (pipe(mReturnPipe) == -1)
                {
                    logError("CAmSerializer could not create mReturnPipe!");
                    throw std::runtime_error("CAmSerializer Could not open mReturnPipe!");
                }

                short event = 0;
                event |= POLLIN;
                mpSocketHandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, &checkerCallbackT, &dispatcherCallbackT, NULL, mHandle);
            }

            ~CAmSerializer()
            {
                mpSocketHandler->removeFDPoll(mHandle);
                close(mPipe[0]);
                close(mPipe[1]);
                close(mReturnPipe[0]);
                close(mReturnPipe[1]);
            }
        };

    } /* namespace V1 */

    namespace V2
    {
        class CAmSerializer
        {
            class CAmDelegate
            {
            public:
                typedef enum
                    :bool
                    {
                        SyncCallType = false, AsyncCallType = true
                } CallType;

                virtual ~CAmDelegate()
                {
                }
                ;
                virtual CallType call(int* pipe)=0;
            };

            template<class TInvocation>
            class CAmDelegateAsyncImpl: public CAmDelegate
            {
                TInvocation mInvocation;
            public:
                friend class CAmSerializer;
                CAmDelegateAsyncImpl(TInvocation && invocation) :
                        mInvocation(std::move(invocation))
                {
                }

                CallType call(int* pipe)
                {
                    (void) pipe;
                    mInvocation();
                    return (AsyncCallType);
                }
                ;
            };

            template<class TInvocation, class TRet>
            class CAmDelegateSyncImpl: public CAmDelegate
            {
                TInvocation mInvocation;
                TRet & mReturn;
            public:
                friend class CAmSerializer;
                CAmDelegateSyncImpl(TInvocation && invocation, TRet && ret) :
                        mInvocation(std::move(invocation)), mReturn(ret)
                {
                }

                CallType call(int* pipe)
                {
                    mReturn = mInvocation();
                    ssize_t result(-1);
                    result = write(pipe[1], this, sizeof(this));
                    if (result == -1)
                        logError("CAmSerializer: Problem writing into pipe! Error No:", errno);
                    return (SyncCallType);
                }
                ;
            };

            template<class TInvocation>
            class CAmDelegateSyncVoidImpl: public CAmDelegate
            {
                TInvocation mInvocation;
            public:
                friend class CAmSerializer;
                CAmDelegateSyncVoidImpl(TInvocation && invocation) :
                        mInvocation(std::move(invocation))
                {
                }

                CallType call(int* pipe)
                {
                    mInvocation();
                    ssize_t result(-1);
                    result = write(pipe[1], this, sizeof(this));
                    if (result == -1)
                        logError("CAmSerializer: Problem writing into pipe! Error No:", errno);
                    return (SyncCallType);
                }
                ;
            };

            typedef CAmDelegate* CAmDelegagePtr; 

            void sendSync(CAmDelegagePtr pDelegate)
            {
                send(pDelegate);
                int numReads;
                CAmDelegagePtr *p = NULL;
                if ((numReads = read(mReturnPipe[0], &p, sizeof(p))) == -1)
                {
                    logError("CAmSerializer::doSyncCall could not read pipe!");
                    throw std::runtime_error("CAmSerializer Could not read pipe!");
                }
            }

            inline void send(CAmDelegagePtr p)
            {
                if (write(mPipe[1], &p, sizeof(p)) == -1)
                {
                    throw std::runtime_error("could not write to pipe !");
                }
            }

            int mPipe[2]; 
            int mReturnPipe[2]; 
            sh_pollHandle_t mHandle;
            CAmSocketHandler* mpSocketHandler;
            std::deque<CAmDelegagePtr> mListDelegatePointers; 

        public:

            size_t getListDelegatePointers()
            {
                return mListDelegatePointers.size();
            }

            template<class TFunc>
            void asyncInvocation(TFunc invocation)
            {
                static_assert(std::is_bind_expression<TFunc>::value,"The type is not produced by std::bind");
                typedef CAmDelegateAsyncImpl<TFunc> AsyncDelegate;
                AsyncDelegate *pImp = new AsyncDelegate(std::forward<TFunc>(invocation));
                send(pImp);
                //Do not delete the pointer. It will be deleted automatically later.
            }

            template<class TClass, class TMeth, class TRet, class ... TArgs>
            void asyncCall(TClass* instance, TMeth method, TArgs && ... arguments)
            {
                auto invocation = std::bind(method, instance, std::forward<TArgs>(arguments)...);
                asyncInvocation(invocation);
            }

            template<class TClass, class TMeth, class ... TArgs>
            void asyncCall(TClass* instance, TMeth method, TArgs && ... arguments)
            {
                auto invocation = std::bind(method, instance, std::forward<TArgs>(arguments)...);
                asyncInvocation(invocation);
            }

            template<class TFunc, class TRet>
            void syncInvocation(TFunc invocation, TRet && result)
            {
                static_assert(std::is_bind_expression<TFunc>::value,"The type is not produced by std::bind");

                typedef CAmDelegateSyncImpl<TFunc, TRet> SyncDelegate;

                SyncDelegate *pImp = new SyncDelegate(std::forward<TFunc>(invocation), std::forward<TRet>(result));
                sendSync(pImp);
                //Delete the pointer.
                delete pImp;
            }

            template<class TFunc>
            void syncInvocation(TFunc invocation)
            {
                static_assert(std::is_bind_expression<TFunc>::value,"The type is not produced by std::bind");

                typedef CAmDelegateSyncVoidImpl<TFunc> SyncDelegate;

                SyncDelegate *pImp = new SyncDelegate(std::forward<TFunc>(invocation));
                sendSync(pImp);
                //Delete the pointer.
                delete pImp;
            }
            template<class TClass, class TMeth, class TRet, class ... TArgs>
            void syncCall(TClass* instance, TMeth method, TRet & result, TArgs && ... arguments)
            {
                auto invocation = std::bind(method, instance, std::ref(arguments)...);
                syncInvocation(invocation, result);
            }

            template<class TClass, class TMeth, class ... TArgs>
            void syncCall(TClass* instance, TMeth method, TArgs && ... arguments)
            {
                auto invocation = std::bind(method, instance, std::ref(arguments)...);
                syncInvocation(invocation);
            }

            void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData)
            {
                (void) handle;
                (void) userData;
                int numReads;
                CAmDelegagePtr listPointers[3];
                if ((numReads = read(pollfd.fd, &listPointers, sizeof(listPointers))) == -1)
                {
                    logError("CAmSerializer::receiverCallback could not read pipe!");
                    throw std::runtime_error("CAmSerializer Could not read pipe!");
                }
                mListDelegatePointers.assign(listPointers, listPointers + (numReads / sizeof(CAmDelegagePtr)));
            }

            bool checkerCallback(const sh_pollHandle_t handle, void* userData)
            {
                (void) handle;
                (void) userData;
                if (mListDelegatePointers.empty())
                    return (false);
                return (true);
            }

            bool dispatcherCallback(const sh_pollHandle_t handle, void* userData)
            {
                (void) handle;
                (void) userData;
                CAmDelegagePtr delegatePoiter = mListDelegatePointers.front();
                mListDelegatePointers.pop_front();
                if (delegatePoiter->call(mReturnPipe))
                    delete delegatePoiter;
                if (mListDelegatePointers.empty())
                    return (false);
                return (true);
            }

            TAmShPollFired<CAmSerializer> receiverCallbackT;
            TAmShPollDispatch<CAmSerializer> dispatcherCallbackT;
            TAmShPollCheck<CAmSerializer> checkerCallbackT;

            CAmSerializer(CAmSocketHandler *iSocketHandler) :
                    mPipe(), //
                            mReturnPipe(), //
                            mHandle(),
                            mpSocketHandler(iSocketHandler),
                            mListDelegatePointers(), //
                            receiverCallbackT(this, &CAmSerializer::receiverCallback), //
                            dispatcherCallbackT(this, &CAmSerializer::dispatcherCallback), //
                            checkerCallbackT(this, &CAmSerializer::checkerCallback)
            {
                assert(NULL!=iSocketHandler);

                if (pipe(mPipe) == -1)
                {
                    logError("CAmSerializer could not create pipe!");
                    throw std::runtime_error("CAmSerializer Could not open pipe!");
                }

                if (pipe(mReturnPipe) == -1)
                {
                    logError("CAmSerializer could not create mReturnPipe!");
                    throw std::runtime_error("CAmSerializer Could not open mReturnPipe!");
                }

                short event = 0;
                event |= POLLIN;
                mpSocketHandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, &checkerCallbackT, &dispatcherCallbackT, NULL, mHandle);
            }

            ~CAmSerializer()
            {
                mpSocketHandler->removeFDPoll(mHandle);
                close(mPipe[0]);
                close(mPipe[1]);
                close(mReturnPipe[0]);
                close(mReturnPipe[1]);
            }
        };
    } /* namespace V2 */

    typedef V1::CAmSerializer CAmSerializer DEPRECATED("You should use V2::CAmSerializer instead!");

} /* namespace am */
#endif /* CAMSERIALIZER_H_ */