CAmSerializer.h

Go to the documentation of this file.

#ifndef CAMSERIALIZER_H_
#define CAMSERIALIZER_H_

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

namespace am
{
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]; 
    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(),//
            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;
        sh_pollHandle_t handle;
        event |= POLLIN;
        iSocketHandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, &checkerCallbackT, &dispatcherCallbackT, NULL, handle);
    }

    ~CAmSerializer()
    {
        close(mPipe[0]);
        close(mPipe[1]);
        close(mReturnPipe[0]);
        close(mReturnPipe[1]);
    }
};
} /* namespace am */
#endif /* CAMSERIALIZER_H_ */