audiomanager.git/patch/CAmSerializer_8h_source.html

- #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_ */

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1, Targ2 &argument2), Targ argument, Targ1 argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:505

-am::CAmSerializer
magic class that does the serialization of functions calls The constructor must be called within the ...
Definition: CAmSerializer.h:49

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 argument1, Targ2 &argument2), Targ &argument, Targ1 argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:545

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3), TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2, Targ3 &argument3)
calls a function with four arguments synchronously threadsafe.
Definition: CAmSerializer.h:682

-am::TAmShPollCheck
template for a callback
Definition: CAmSocketHandler.h:449

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 &argument1, Targ2 &argument2), Targ &argument, Targ1 &argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:525

-am::CAmSerializer::syncCall
void syncCall(TClass *instance, TRet(TClass::*method)(TArgs...), TRet &result, TArgs &...arguments)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:291

-am::CAmSerializer::getListDelegatePoiters
int getListDelegatePoiters()
get the size of delegate pointers
Definition: CAmSerializer.h:264

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:474

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 &argument1, Targ2 argument2), Targ &argument, Targ1 &argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:535

-am::TAmShPollFired
make private, not public template for a callback
Definition: CAmSocketHandler.h:429

-am::CAmSerializer::syncCall
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)
calls a function with six arguments synchronously threadsafe.
Definition: CAmSerializer.h:704

-am::CAmSerializer::checkerCallbackT
TAmShPollCheck< CAmSerializer > checkerCallbackT
Definition: CAmSerializer.h:758

-am::CAmSocketHandler
The am::CAmSocketHandler implements a mainloop for the AudioManager.
Definition: CAmSocketHandler.h:94

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 &argument1), Targ &argument, Targ1 &argument1)
calls a function with two arguments asynchronously threadsafe, both arguments are references...
Definition: CAmSerializer.h:464

-am::sh_pollHandle_t
uint16_t sh_pollHandle_t
this is a handle for a filedescriptor to be used with the SocketHandler
Definition: CAmSocketHandler.h:37

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 argument1, Targ2 argument2), Targ &argument, Targ1 argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:484

-am::CAmSerializer::doAsyncCall
void doAsyncCall(Class intsance, Method method, Tuple &arguments)
instantiates a async delegate with given arguments and sends the delegate pointer over the pipe ...
Definition: CAmSerializer.h:210

+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_ */
am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 argument1), Targ &argument, Targ1 argument1)
calls a function with two arguments asynchronously threadsafe, first argument is a reference...
Definition: CAmSerializer.h:477

+am::V2::CAmSerializer::asyncInvocation
void asyncInvocation(TFunc invocation)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:999

+am
A Common-API wrapper class, which loads the common-api runtime and instantiates all necessary objects...
Definition: CAmCommandReceiver.h:29

+am::V1::CAmSerializer
Definition: CAmSerializer.h:87

+am::V1::CAmSerializer::~CAmSerializer
~CAmSerializer()
Definition: CAmSerializer.h:840

+am::V2::CAmSerializer::receiverCallbackT
TAmShPollFired< CAmSerializer > receiverCallbackT
Definition: CAmSerializer.h:1166

+indices
Helper structures used within std::bind for automatically identification of all placeholders.
Definition: CAmSerializer.h:33

+am::V1::CAmSerializer::receiverCallbackT
TAmShPollFired< CAmSerializer > receiverCallbackT
Definition: CAmSerializer.h:803

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4), TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2, Targ3 &argument3, Targ4 &argument4)
calls a function with five arguments synchronously threadsafe.
Definition: CAmSerializer.h:739

+am::V1::CAmSerializer::dispatcherCallback
bool dispatcherCallback(const sh_pollHandle_t handle, void *userData)
dispatcher callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:790

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:521

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(), TretVal &retVal)
calls a synchronous function with no arguments threadsafe
Definition: CAmSerializer.h:630

+am::TAmShPollCheck
template for a callback
Definition: CAmSocketHandler.h:129

+am::V2::CAmSerializer::~CAmSerializer
~CAmSerializer()
Definition: CAmSerializer.h:1203

+am::V1::CAmSerializer::dispatcherCallbackT
TAmShPollDispatch< CAmSerializer > dispatcherCallbackT
Definition: CAmSerializer.h:804

+am::V2::CAmSerializer::getListDelegatePointers
size_t getListDelegatePointers()
get the size of delegate pointers
Definition: CAmSerializer.h:984

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, Targ1Call), TretVal &retVal, Targ &argument, Targ1 &argument1)
calls a function with two arguments synchronously threadsafe.
Definition: CAmSerializer.h:685

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass *instance, TRet(TClass::*method)(TArgs...), TArgs &...arguments)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:365

+am::V1::CAmSerializer::getListDelegatePoiters
int getListDelegatePoiters()
get the size of delegate pointers
Definition: CAmSerializer.h:311

+am::TAmShPollFired
make private, not public template for a callback
Definition: CAmSocketHandler.h:108

+am::CAmSocketHandler
The am::CAmSocketHandler implements a mainloop for the AudioManager.
Definition: CAmSocketHandler.h:216

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3)
calls a function with four arguments asynchronously threadsafe.
Definition: CAmSerializer.h:601

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ), Targ argument)
calls a function with one arguments asynchronously threadsafe
Definition: CAmSerializer.h:416

+std
STL namespace.

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 argument1, Targ2 argument2), Targ &argument, Targ1 argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:531

+am::V2::CAmSerializer::syncCall
void syncCall(TClass *instance, TMeth method, TArgs &&...arguments)
Definition: CAmSerializer.h:1115

+am::sh_pollHandle_t
uint16_t sh_pollHandle_t
this is a handle for a filedescriptor to be used with the SocketHandler
Definition: CAmSocketHandler.h:51

 CAmDltWrapper.h
SPDX license identifier: MPL-2.0.

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4), TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2, Targ3 &argument3, Targ4 &argument4)
calls a function with five arguments synchronously threadsafe.
Definition: CAmSerializer.h:693

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &), Targ &argument)
calls a function with one argument called by reference asynchronously threadsafe
Definition: CAmSerializer.h:396

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(), TretVal &retVal)
calls a synchronous function with no arguments threadsafe
Definition: CAmSerializer.h:584

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall) const, TretVal &retVal, Targ &argument)
calls a function with one argument synchronous threadsafe for const functions.
Definition: CAmSerializer.h:628

-am::CAmSocketHandler::addFDPoll
am_Error_e addFDPoll(const int fd, const short event, IAmShPollPrepare *prepare, IAmShPollFired *fired, IAmShPollCheck *check, IAmShPollDispatch *dispatch, void *userData, sh_pollHandle_t &handle)
Adds a filedescriptor to the polling loop.
Definition: CAmSocketHandler.cpp:195

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall), TretVal &retVal, Targ &argument)
calls a function with one argument synchronous threadsafe
Definition: CAmSerializer.h:617

-am::TAmShPollDispatch
template for a callback
Definition: CAmSocketHandler.h:469

-am::CAmSerializer::CAmSerializer
CAmSerializer(CAmSocketHandler *iSocketHandler)
The constructor must be called in the mainthread context !
Definition: CAmSerializer.h:764

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2), TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2)
calls a function with three arguments synchronously threadsafe.
Definition: CAmSerializer.h:660

-am::CAmSerializer::doSyncCall
void doSyncCall(Class intsance, Method method, Return &result, Tuple &arguments)
instantiates a sync delegate with given arguments and sends the delegate pointer over the pipe ...
Definition: CAmSerializer.h:223

-am::CAmSerializer::asyncCall
void asyncCall(TClass *instance, void(TClass::*function)())
calls a function with no arguments threadsafe
Definition: CAmSerializer.h:342

-am::CAmSerializer::dispatcherCallbackT
TAmShPollDispatch< CAmSerializer > dispatcherCallbackT
Definition: CAmSerializer.h:757

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 &argument1, Targ2 argument2), Targ argument, Targ1 &argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:495

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3)
calls a function with four arguments asynchronously threadsafe.
Definition: CAmSerializer.h:555

-am::CAmSerializer::asyncCall
void asyncCall(TClass *instance, TRet(TClass::*method)(TArgs...), TArgs &...arguments)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:318

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, Targ1Call) const, TretVal &retVal, Targ &argument, Targ1 &argument1)
calls a function with two arguments synchronously threadsafe const.
Definition: CAmSerializer.h:649

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass *instance, void(TClass::*function)())
calls a function with no arguments threadsafe
Definition: CAmSerializer.h:389

+am::CAmSocketHandler::removeFDPoll
am_Error_e removeFDPoll(const sh_pollHandle_t handle)
removes a filedescriptor from the poll loop
Definition: CAmSocketHandler.cpp:424

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, Targ1Call) const, TretVal &retVal, Targ &argument, Targ1 &argument1)
calls a function with two arguments synchronously threadsafe const.
Definition: CAmSerializer.h:695

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2) const, TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2)
calls a const function with three arguments synchronously threadsafe.
Definition: CAmSerializer.h:717

+build_indices
Definition: CAmSerializer.h:38

+am::V2::CAmSerializer
Definition: CAmSerializer.h:856

+am::V2::CAmSerializer::CAmSerializer
CAmSerializer(CAmSocketHandler *iSocketHandler)
The constructor must be called in the mainthread context !
Definition: CAmSerializer.h:1174

+am::V1::CAmSerializer::CAmSerializer
CAmSerializer(CAmSocketHandler *iSocketHandler)
The constructor must be called in the mainthread context !
Definition: CAmSerializer.h:811

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 &argument1, Targ2 argument2), Targ argument, Targ1 &argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:541

+am::TAmShPollDispatch
template for a callback
Definition: CAmSocketHandler.h:150

+am::V2::CAmSerializer::syncInvocation
void syncInvocation(TFunc invocation)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:1075

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall) const, TretVal &retVal, Targ &argument)
calls a function with one argument synchronous threadsafe for const functions.
Definition: CAmSerializer.h:674

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3), TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2, Targ3 &argument3)
calls a function with four arguments synchronously threadsafe.
Definition: CAmSerializer.h:728

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 &argument1, Targ2 &argument2), Targ argument, Targ1 &argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:561

+DEPRECATED
#define DEPRECATED(MSG)
Definition: CAmSerializer.h:62

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 &argument1), Targ &argument, Targ1 &argument1)
calls a function with two arguments asynchronously threadsafe, both arguments are references...
Definition: CAmSerializer.h:511

+am::V2::CAmSerializer::dispatcherCallback
bool dispatcherCallback(const sh_pollHandle_t handle, void *userData)
dispatcher callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:1153

+am::V1::CAmSerializer::syncCall
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)
calls a function with six arguments synchronously threadsafe.
Definition: CAmSerializer.h:750

+am::CAmSocketHandler::addFDPoll
am_Error_e addFDPoll(const int fd, const short event, std::function< void(const sh_pollHandle_t handle, void *userData)> prepare, std::function< void(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)> fired, std::function< bool(const sh_pollHandle_t handle, void *userData)> check, std::function< bool(const sh_pollHandle_t handle, void *userData)> dispatch, void *userData, sh_pollHandle_t &handle)
Adds a filedescriptor to the polling loop.
Definition: CAmSocketHandler.cpp:353

+am::V2::CAmSerializer::dispatcherCallbackT
TAmShPollDispatch< CAmSerializer > dispatcherCallbackT
Definition: CAmSerializer.h:1167

+am::V1::CAmSerializer::doSyncCall
void doSyncCall(Class intsance, Method method, Return &result, Tuple &arguments)
instantiates a sync delegate with given arguments and sends the delegate pointer over the pipe ...
Definition: CAmSerializer.h:268

 CAmSocketHandler.h
SPDX license identifier: MPL-2.0.

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 argument1), Targ &argument, Targ1 argument1)
calls a function with two arguments asynchronously threadsafe, first argument is a reference...
Definition: CAmSerializer.h:430

-am::logError
void logError(T value, TArgs...args)
logs given values with errorlevel with the default context
Definition: CAmDltWrapper.h:416

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1)
calls a function with two arguments asynchronously threadsafe.
Definition: CAmSerializer.h:413

-am::CAmSerializer::receiverCallback
void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
receiver callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:714

-am::CAmSerializer::checkerCallback
bool checkerCallback(const sh_pollHandle_t handle, void *userData)
checker callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:731

-am::CAmSerializer::receiverCallbackT
TAmShPollFired< CAmSerializer > receiverCallbackT
Definition: CAmSerializer.h:756

-am::CAmSerializer::dispatcherCallback
bool dispatcherCallback(const sh_pollHandle_t handle, void *userData)
dispatcher callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:743

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 &argument1, Targ2 &argument2), Targ argument, Targ1 &argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:515

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2) const, TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2)
calls a const function with three arguments synchronously threadsafe.
Definition: CAmSerializer.h:671

-am::CAmSerializer::~CAmSerializer
~CAmSerializer()
Definition: CAmSerializer.h:792

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 &argument1), Targ argument, Targ1 &argument1)
calls a function with two arguments asynchronously threadsafe, second argument is a reference...
Definition: CAmSerializer.h:447

-am::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, Targ1Call), TretVal &retVal, Targ &argument, Targ1 &argument1)
calls a function with two arguments synchronously threadsafe.
Definition: CAmSerializer.h:639

-am::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ), Targ argument)
calls a function with one arguments asynchronously threadsafe
Definition: CAmSerializer.h:369

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall, TargCall1, TargCall2), TretVal &retVal, Targ &argument, Targ1 &argument1, Targ2 &argument2)
calls a function with three arguments synchronously threadsafe.
Definition: CAmSerializer.h:706

+am::logError
void logError(T value, TArgs...args)
logs given values with errorlevel with the default context
Definition: CAmDltWrapper.h:431

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1)
calls a function with two arguments asynchronously threadsafe.
Definition: CAmSerializer.h:460

+am::V1::CAmSerializer::syncCall
void syncCall(TClass1 *instance, TretVal(TClass1::*function)(TargCall), TretVal &retVal, Targ &argument)
calls a function with one argument synchronous threadsafe
Definition: CAmSerializer.h:663

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 argument1, Targ2 &argument2), Targ argument, Targ1 argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:551

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 &argument1, Targ2 argument2), Targ &argument, Targ1 &argument1, Targ2 argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:581

+am::V1::CAmSerializer::doAsyncCall
void doAsyncCall(Class intsance, Method method, Tuple &arguments)
instantiates a async delegate with given arguments and sends the delegate pointer over the pipe ...
Definition: CAmSerializer.h:255

+am::V1::CAmSerializer::syncCall
void syncCall(TClass *instance, TRet(TClass::*method)(TArgs...), TRet &result, TArgs &...arguments)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:338

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &), Targ &argument)
calls a function with one argument called by reference asynchronously threadsafe
Definition: CAmSerializer.h:443

+am::V2::CAmSerializer::checkerCallback
bool checkerCallback(const sh_pollHandle_t handle, void *userData)
checker callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:1141

+am::V1::CAmSerializer::receiverCallback
void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
receiver callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:761

+am::V2::CAmSerializer::checkerCallbackT
TAmShPollCheck< CAmSerializer > checkerCallbackT
Definition: CAmSerializer.h:1168

+am::V1::CAmSerializer::checkerCallbackT
TAmShPollCheck< CAmSerializer > checkerCallbackT
Definition: CAmSerializer.h:805

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ argument, Targ1 &argument1), Targ argument, Targ1 &argument1)
calls a function with two arguments asynchronously threadsafe, second argument is a reference...
Definition: CAmSerializer.h:494

+am::V2::CAmSerializer::receiverCallback
void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
receiver callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:1124

+am::V1::CAmSerializer::checkerCallback
bool checkerCallback(const sh_pollHandle_t handle, void *userData)
checker callback for sockethandling, for more, see CAmSocketHandler
Definition: CAmSerializer.h:778

+am::V2::CAmSerializer::asyncCall
void asyncCall(TClass *instance, TMeth method, TArgs &&...arguments)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:1028

+am::V2::CAmSerializer::asyncCall
void asyncCall(TClass *instance, TMeth method, TArgs &&...arguments)
Definition: CAmSerializer.h:1035

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 argument1, Targ2 &argument2), Targ &argument, Targ1 argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:591

+am::V2::CAmSerializer::syncInvocation
void syncInvocation(TFunc invocation, TRet &&result)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:1053

+placeholder
Definition: CAmSerializer.h:47

+am::V2::CAmSerializer::syncCall
void syncCall(TClass *instance, TMeth method, TRet &result, TArgs &&...arguments)
calls a function with variadic arguments threadsafe
Definition: CAmSerializer.h:1108

+am::V1::CAmSerializer::asyncCall
void asyncCall(TClass1 *instance, void(TClass1::*function)(Targ &argument, Targ1 &argument1, Targ2 &argument2), Targ &argument, Targ1 &argument1, Targ2 &argument2)
calls a function with three arguments asynchronously threadsafe.
Definition: CAmSerializer.h:571