diff options
Diffstat (limited to 'core/command_queue_mt.h')
| -rw-r--r-- | core/command_queue_mt.h | 914 |
1 files changed, 487 insertions, 427 deletions
diff --git a/core/command_queue_mt.h b/core/command_queue_mt.h index 3975df7658..3a859c809c 100644 --- a/core/command_queue_mt.h +++ b/core/command_queue_mt.h @@ -29,11 +29,11 @@ #ifndef COMMAND_QUEUE_MT_H #define COMMAND_QUEUE_MT_H -#include "typedefs.h" -#include "os/semaphore.h" -#include "os/mutex.h" #include "os/memory.h" +#include "os/mutex.h" +#include "os/semaphore.h" #include "simple_type.h" +#include "typedefs.h" /** @author Juan Linietsky <reduzio@gmail.com> */ @@ -48,69 +48,69 @@ class CommandQueueMT { struct CommandBase { - virtual void call()=0; - virtual ~CommandBase() {}; + virtual void call() = 0; + virtual ~CommandBase(){}; }; - template<class T,class M> + template <class T, class M> struct Command0 : public CommandBase { - T*instance; + T *instance; M method; virtual void call() { (instance->*method)(); } }; - template<class T,class M,class P1> + template <class T, class M, class P1> struct Command1 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; virtual void call() { (instance->*method)(p1); } }; - template<class T,class M,class P1,class P2> + template <class T, class M, class P1, class P2> struct Command2 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; - virtual void call() { (instance->*method)(p1,p2); } + virtual void call() { (instance->*method)(p1, p2); } }; - template<class T,class M,class P1,class P2,class P3> + template <class T, class M, class P1, class P2, class P3> struct Command3 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; typename GetSimpleTypeT<P3>::type_t p3; - virtual void call() { (instance->*method)(p1,p2,p3); } + virtual void call() { (instance->*method)(p1, p2, p3); } }; - template<class T,class M,class P1,class P2,class P3,class P4> + template <class T, class M, class P1, class P2, class P3, class P4> struct Command4 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; typename GetSimpleTypeT<P3>::type_t p3; typename GetSimpleTypeT<P4>::type_t p4; - virtual void call() { (instance->*method)(p1,p2,p3,p4); } + virtual void call() { (instance->*method)(p1, p2, p3, p4); } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5> + template <class T, class M, class P1, class P2, class P3, class P4, class P5> struct Command5 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -118,13 +118,13 @@ class CommandQueueMT { typename GetSimpleTypeT<P4>::type_t p4; typename GetSimpleTypeT<P5>::type_t p5; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5); } + virtual void call() { (instance->*method)(p1, p2, p3, p4, p5); } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6> struct Command6 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -133,13 +133,13 @@ class CommandQueueMT { typename GetSimpleTypeT<P5>::type_t p5; typename GetSimpleTypeT<P6>::type_t p6; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6); } + virtual void call() { (instance->*method)(p1, p2, p3, p4, p5, p6); } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7> struct Command7 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -149,13 +149,13 @@ class CommandQueueMT { typename GetSimpleTypeT<P6>::type_t p6; typename GetSimpleTypeT<P7>::type_t p7; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6,p7); } + virtual void call() { (instance->*method)(p1, p2, p3, p4, p5, p6, p7); } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class P8> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8> struct Command8 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -166,96 +166,120 @@ class CommandQueueMT { typename GetSimpleTypeT<P7>::type_t p7; typename GetSimpleTypeT<P8>::type_t p8; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6,p7,p8); } + virtual void call() { (instance->*method)(p1, p2, p3, p4, p5, p6, p7, p8); } }; /* comands that return */ - template<class T,class M,class R> + template <class T, class M, class R> struct CommandRet0 : public CommandBase { - T*instance; + T *instance; M method; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class R> + template <class T, class M, class P1, class R> struct CommandRet1 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class R> + template <class T, class M, class P1, class P2, class R> struct CommandRet2 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1,p2); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1, p2); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class R> + template <class T, class M, class P1, class P2, class P3, class R> struct CommandRet3 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; typename GetSimpleTypeT<P3>::type_t p3; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1,p2,p3); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1, p2, p3); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class R> + template <class T, class M, class P1, class P2, class P3, class P4, class R> struct CommandRet4 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; typename GetSimpleTypeT<P3>::type_t p3; typename GetSimpleTypeT<P4>::type_t p4; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1, p2, p3, p4); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class R> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class R> struct CommandRet5 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; typename GetSimpleTypeT<P3>::type_t p3; typename GetSimpleTypeT<P4>::type_t p4; typename GetSimpleTypeT<P5>::type_t p5; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4,p5); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1, p2, p3, p4, p5); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class R> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class R> struct CommandRet6 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -263,16 +287,20 @@ class CommandQueueMT { typename GetSimpleTypeT<P4>::type_t p4; typename GetSimpleTypeT<P5>::type_t p5; typename GetSimpleTypeT<P6>::type_t p6; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4,p5,p6); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1, p2, p3, p4, p5, p6); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class R> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class R> struct CommandRet7 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -281,16 +309,20 @@ class CommandQueueMT { typename GetSimpleTypeT<P5>::type_t p5; typename GetSimpleTypeT<P6>::type_t p6; typename GetSimpleTypeT<P7>::type_t p7; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4,p5,p6,p7); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1, p2, p3, p4, p5, p6, p7); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class P8,class R> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class R> struct CommandRet8 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -300,56 +332,72 @@ class CommandQueueMT { typename GetSimpleTypeT<P6>::type_t p6; typename GetSimpleTypeT<P7>::type_t p7; typename GetSimpleTypeT<P8>::type_t p8; - R* ret; + R *ret; SyncSemaphore *sync; - virtual void call() { *ret = (instance->*method)(p1,p2,p3,p4,p5,p6,p7,p8); sync->sem->post(); sync->in_use=false; } + virtual void call() { + *ret = (instance->*method)(p1, p2, p3, p4, p5, p6, p7, p8); + sync->sem->post(); + sync->in_use = false; + } }; /** commands that don't return but sync */ /* comands that return */ - template<class T,class M> + template <class T, class M> struct CommandSync0 : public CommandBase { - T*instance; + T *instance; M method; SyncSemaphore *sync; - virtual void call() { (instance->*method)(); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1> + template <class T, class M, class P1> struct CommandSync1 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2> + template <class T, class M, class P1, class P2> struct CommandSync2 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1,p2); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1, p2); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3> + template <class T, class M, class P1, class P2, class P3> struct CommandSync3 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -357,13 +405,17 @@ class CommandQueueMT { SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1,p2,p3); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1, p2, p3); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4> + template <class T, class M, class P1, class P2, class P3, class P4> struct CommandSync4 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -372,13 +424,17 @@ class CommandQueueMT { SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1,p2,p3,p4); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1, p2, p3, p4); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5> + template <class T, class M, class P1, class P2, class P3, class P4, class P5> struct CommandSync5 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -388,13 +444,17 @@ class CommandQueueMT { SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1, p2, p3, p4, p5); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6> struct CommandSync6 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -405,13 +465,17 @@ class CommandQueueMT { SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1, p2, p3, p4, p5, p6); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7> struct CommandSync7 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -423,13 +487,17 @@ class CommandQueueMT { SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6,p7); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1, p2, p3, p4, p5, p6, p7); + sync->sem->post(); + sync->in_use = false; + } }; - template<class T,class M,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class P8> + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8> struct CommandSync8 : public CommandBase { - T*instance; + T *instance; M method; typename GetSimpleTypeT<P1>::type_t p1; typename GetSimpleTypeT<P2>::type_t p2; @@ -442,18 +510,21 @@ class CommandQueueMT { SyncSemaphore *sync; - virtual void call() { (instance->*method)(p1,p2,p3,p4,p5,p6,p7,p8); sync->sem->post(); sync->in_use=false; } + virtual void call() { + (instance->*method)(p1, p2, p3, p4, p5, p6, p7, p8); + sync->sem->post(); + sync->in_use = false; + } }; /***** BASE *******/ enum { - COMMAND_MEM_SIZE_KB=256, - COMMAND_MEM_SIZE=COMMAND_MEM_SIZE_KB*1024, - SYNC_SEMAPHORES=8 + COMMAND_MEM_SIZE_KB = 256, + COMMAND_MEM_SIZE = COMMAND_MEM_SIZE_KB * 1024, + SYNC_SEMAPHORES = 8 }; - uint8_t command_mem[COMMAND_MEM_SIZE]; uint32_t read_ptr; uint32_t write_ptr; @@ -461,255 +532,247 @@ class CommandQueueMT { Mutex *mutex; Semaphore *sync; - - template<class T> - T* allocate() { + template <class T> + T *allocate() { // alloc size is size+T+safeguard - uint32_t alloc_size=sizeof(T)+sizeof(uint32_t); + uint32_t alloc_size = sizeof(T) + sizeof(uint32_t); - tryagain: + tryagain: if (write_ptr < read_ptr) { // behind read_ptr, check that there is room - if ( (read_ptr-write_ptr) <= alloc_size ) + if ((read_ptr - write_ptr) <= alloc_size) return NULL; } else if (write_ptr >= read_ptr) { // ahead of read_ptr, check that there is room - - if ( (COMMAND_MEM_SIZE-write_ptr) < alloc_size+4 ) { + if ((COMMAND_MEM_SIZE - write_ptr) < alloc_size + 4) { // no room at the end, wrap down; - if (read_ptr==0) // dont want write_ptr to become read_ptr + if (read_ptr == 0) // dont want write_ptr to become read_ptr return NULL; // if this happens, it's a bug - ERR_FAIL_COND_V( (COMMAND_MEM_SIZE-write_ptr) < sizeof(uint32_t), NULL ); + ERR_FAIL_COND_V((COMMAND_MEM_SIZE - write_ptr) < sizeof(uint32_t), NULL); // zero means, wrap to begining - uint32_t * p = (uint32_t*)&command_mem[write_ptr]; - *p=0; - write_ptr=0; + uint32_t *p = (uint32_t *)&command_mem[write_ptr]; + *p = 0; + write_ptr = 0; goto tryagain; } } // allocate the size - uint32_t * p = (uint32_t*)&command_mem[write_ptr]; - *p=sizeof(T); - write_ptr+=sizeof(uint32_t); + uint32_t *p = (uint32_t *)&command_mem[write_ptr]; + *p = sizeof(T); + write_ptr += sizeof(uint32_t); // allocate the command - T* cmd = memnew_placement( &command_mem[write_ptr], T ); - write_ptr+=sizeof(T); + T *cmd = memnew_placement(&command_mem[write_ptr], T); + write_ptr += sizeof(T); return cmd; - } - template<class T> - T* allocate_and_lock() { + template <class T> + T *allocate_and_lock() { lock(); - T* ret; + T *ret; - while ( (ret=allocate<T>())==NULL ) { + while ((ret = allocate<T>()) == NULL) { unlock(); // sleep a little until fetch happened and some room is made wait_for_flush(); lock(); - } return ret; } - bool flush_one() { - tryagain: + tryagain: // tried to read an empty queue - if (read_ptr == write_ptr ) + if (read_ptr == write_ptr) return false; - uint32_t size = *(uint32_t*)( &command_mem[read_ptr] ); + uint32_t size = *(uint32_t *)(&command_mem[read_ptr]); - if (size==0) { + if (size == 0) { //end of ringbuffer, wrap - read_ptr=0; + read_ptr = 0; goto tryagain; } - read_ptr+=sizeof(uint32_t); + read_ptr += sizeof(uint32_t); - CommandBase *cmd = reinterpret_cast<CommandBase*>( &command_mem[read_ptr] ); + CommandBase *cmd = reinterpret_cast<CommandBase *>(&command_mem[read_ptr]); cmd->call(); cmd->~CommandBase(); - read_ptr+=size; + read_ptr += size; return true; } - void lock(); void unlock(); void wait_for_flush(); - SyncSemaphore* _alloc_sync_sem(); - + SyncSemaphore *_alloc_sync_sem(); public: - /* NORMAL PUSH COMMANDS */ - template<class T, class M> - void push( T * p_instance, M p_method ) { + template <class T, class M> + void push(T *p_instance, M p_method) { - Command0<T,M> * cmd = allocate_and_lock< Command0<T,M> >(); + Command0<T, M> *cmd = allocate_and_lock<Command0<T, M> >(); - cmd->instance=p_instance; - cmd->method=p_method; + cmd->instance = p_instance; + cmd->method = p_method; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1> - void push( T * p_instance, M p_method, P1 p1 ) { + template <class T, class M, class P1> + void push(T *p_instance, M p_method, P1 p1) { - Command1<T,M,P1> * cmd = allocate_and_lock< Command1<T,M,P1> >(); + Command1<T, M, P1> *cmd = allocate_and_lock<Command1<T, M, P1> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1, class P2> - void push( T * p_instance, M p_method, P1 p1, P2 p2 ) { + template <class T, class M, class P1, class P2> + void push(T *p_instance, M p_method, P1 p1, P2 p2) { - Command2<T,M,P1,P2> * cmd = allocate_and_lock< Command2<T,M,P1,P2> >(); + Command2<T, M, P1, P2> *cmd = allocate_and_lock<Command2<T, M, P1, P2> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1, class P2, class P3> - void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3 ) { + template <class T, class M, class P1, class P2, class P3> + void push(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3) { - Command3<T,M,P1,P2,P3> * cmd = allocate_and_lock< Command3<T,M,P1,P2,P3> >(); + Command3<T, M, P1, P2, P3> *cmd = allocate_and_lock<Command3<T, M, P1, P2, P3> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1, class P2, class P3, class P4> - void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4 ) { + template <class T, class M, class P1, class P2, class P3, class P4> + void push(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4) { - Command4<T,M,P1,P2,P3,P4> * cmd = allocate_and_lock< Command4<T,M,P1,P2,P3,P4> >(); + Command4<T, M, P1, P2, P3, P4> *cmd = allocate_and_lock<Command4<T, M, P1, P2, P3, P4> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5> - void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5> + void push(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) { - Command5<T,M,P1,P2,P3,P4,P5> * cmd = allocate_and_lock< Command5<T,M,P1,P2,P3,P4,P5> >(); + Command5<T, M, P1, P2, P3, P4, P5> *cmd = allocate_and_lock<Command5<T, M, P1, P2, P3, P4, P5> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6> - void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6> + void push(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) { - Command6<T,M,P1,P2,P3,P4,P5,P6> * cmd = allocate_and_lock< Command6<T,M,P1,P2,P3,P4,P5,P6> >(); + Command6<T, M, P1, P2, P3, P4, P5, P6> *cmd = allocate_and_lock<Command6<T, M, P1, P2, P3, P4, P5, P6> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7> - void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7> + void push(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) { - Command7<T,M,P1,P2,P3,P4,P5,P6,P7> * cmd = allocate_and_lock< Command7<T,M,P1,P2,P3,P4,P5,P6,P7> >(); + Command7<T, M, P1, P2, P3, P4, P5, P6, P7> *cmd = allocate_and_lock<Command7<T, M, P1, P2, P3, P4, P5, P6, P7> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; - cmd->p7=p7; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; + cmd->p7 = p7; unlock(); if (sync) sync->post(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7,class P8> - void push( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8 ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8> + void push(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) { - Command8<T,M,P1,P2,P3,P4,P5,P6,P7,P8> * cmd = allocate_and_lock< Command8<T,M,P1,P2,P3,P4,P5,P6,P7,P8> >(); + Command8<T, M, P1, P2, P3, P4, P5, P6, P7, P8> *cmd = allocate_and_lock<Command8<T, M, P1, P2, P3, P4, P5, P6, P7, P8> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; - cmd->p7=p7; - cmd->p8=p8; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; + cmd->p7 = p7; + cmd->p8 = p8; unlock(); @@ -717,17 +780,16 @@ public: } /*** PUSH AND RET COMMANDS ***/ + template <class T, class M, class R> + void push_and_ret(T *p_instance, M p_method, R *r_ret) { - template<class T, class M,class R> - void push_and_ret( T * p_instance, M p_method, R* r_ret) { - - CommandRet0<T,M,R> * cmd = allocate_and_lock< CommandRet0<T,M,R> >(); + CommandRet0<T, M, R> *cmd = allocate_and_lock<CommandRet0<T, M, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -735,17 +797,17 @@ public: ss->sem->wait(); } - template<class T, class M, class P1,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, R* r_ret) { + template <class T, class M, class P1, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, R *r_ret) { - CommandRet1<T,M,P1,R> * cmd = allocate_and_lock< CommandRet1<T,M,P1,R> >(); + CommandRet1<T, M, P1, R> *cmd = allocate_and_lock<CommandRet1<T, M, P1, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -753,18 +815,18 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, R* r_ret) { + template <class T, class M, class P1, class P2, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, P2 p2, R *r_ret) { - CommandRet2<T,M,P1,P2,R> * cmd = allocate_and_lock< CommandRet2<T,M,P1,P2,R> >(); + CommandRet2<T, M, P1, P2, R> *cmd = allocate_and_lock<CommandRet2<T, M, P1, P2, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -772,19 +834,19 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, R* r_ret ) { + template <class T, class M, class P1, class P2, class P3, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, R *r_ret) { - CommandRet3<T,M,P1,P2,P3,R> * cmd = allocate_and_lock< CommandRet3<T,M,P1,P2,P3,R> >(); + CommandRet3<T, M, P1, P2, P3, R> *cmd = allocate_and_lock<CommandRet3<T, M, P1, P2, P3, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -792,20 +854,20 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, R* r_ret ) { + template <class T, class M, class P1, class P2, class P3, class P4, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, R *r_ret) { - CommandRet4<T,M,P1,P2,P3,P4,R> * cmd = allocate_and_lock< CommandRet4<T,M,P1,P2,P3,P4,R> >(); + CommandRet4<T, M, P1, P2, P3, P4, R> *cmd = allocate_and_lock<CommandRet4<T, M, P1, P2, P3, P4, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -813,21 +875,21 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, R* r_ret ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, R *r_ret) { - CommandRet5<T,M,P1,P2,P3,P4,P5,R> * cmd = allocate_and_lock< CommandRet5<T,M,P1,P2,P3,P4,P5,R> >(); + CommandRet5<T, M, P1, P2, P3, P4, P5, R> *cmd = allocate_and_lock<CommandRet5<T, M, P1, P2, P3, P4, P5, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -835,22 +897,22 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, R* r_ret ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, R *r_ret) { - CommandRet6<T,M,P1,P2,P3,P4,P5,P6,R> * cmd = allocate_and_lock< CommandRet6<T,M,P1,P2,P3,P4,P5,P6,R> >(); + CommandRet6<T, M, P1, P2, P3, P4, P5, P6, R> *cmd = allocate_and_lock<CommandRet6<T, M, P1, P2, P3, P4, P5, P6, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -858,23 +920,23 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6,class P7,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,P7 p7, R* r_ret ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, R *r_ret) { - CommandRet7<T,M,P1,P2,P3,P4,P5,P6,P7,R> * cmd = allocate_and_lock< CommandRet7<T,M,P1,P2,P3,P4,P5,P6,P7,R> >(); + CommandRet7<T, M, P1, P2, P3, P4, P5, P6, P7, R> *cmd = allocate_and_lock<CommandRet7<T, M, P1, P2, P3, P4, P5, P6, P7, R> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; - cmd->p7=p7; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; + cmd->p7 = p7; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -882,24 +944,24 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6,class P7,class P8,class R> - void push_and_ret( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,P7 p7,P8 p8, R* r_ret ) { - - CommandRet8<T,M,P1,P2,P3,P4,P5,P6,P7,P8,R> * cmd = allocate_and_lock< CommandRet8<T,M,P1,P2,P3,P4,P5,P6,P7,P8,R> >(); - - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; - cmd->p7=p7; - cmd->p8=p8; - cmd->ret=r_ret; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class R> + void push_and_ret(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, R *r_ret) { + + CommandRet8<T, M, P1, P2, P3, P4, P5, P6, P7, P8, R> *cmd = allocate_and_lock<CommandRet8<T, M, P1, P2, P3, P4, P5, P6, P7, P8, R> >(); + + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; + cmd->p7 = p7; + cmd->p8 = p8; + cmd->ret = r_ret; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -907,17 +969,16 @@ public: ss->sem->wait(); } + template <class T, class M> + void push_and_sync(T *p_instance, M p_method) { - template<class T, class M> - void push_and_sync( T * p_instance, M p_method) { + CommandSync0<T, M> *cmd = allocate_and_lock<CommandSync0<T, M> >(); - CommandSync0<T,M> * cmd = allocate_and_lock< CommandSync0<T,M> >(); + cmd->instance = p_instance; + cmd->method = p_method; - cmd->instance=p_instance; - cmd->method=p_method; - - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -925,17 +986,17 @@ public: ss->sem->wait(); } - template<class T, class M, class P1> - void push_and_sync( T * p_instance, M p_method, P1 p1) { + template <class T, class M, class P1> + void push_and_sync(T *p_instance, M p_method, P1 p1) { - CommandSync1<T,M,P1> * cmd = allocate_and_lock< CommandSync1<T,M,P1> >(); + CommandSync1<T, M, P1> *cmd = allocate_and_lock<CommandSync1<T, M, P1> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -943,18 +1004,18 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2> - void push_and_sync( T * p_instance, M p_method, P1 p1, P2 p2) { + template <class T, class M, class P1, class P2> + void push_and_sync(T *p_instance, M p_method, P1 p1, P2 p2) { - CommandSync2<T,M,P1,P2> * cmd = allocate_and_lock< CommandSync2<T,M,P1,P2> >(); + CommandSync2<T, M, P1, P2> *cmd = allocate_and_lock<CommandSync2<T, M, P1, P2> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -962,19 +1023,19 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3> - void push_and_sync( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3 ) { + template <class T, class M, class P1, class P2, class P3> + void push_and_sync(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3) { - CommandSync3<T,M,P1,P2,P3> * cmd = allocate_and_lock< CommandSync3<T,M,P1,P2,P3> >(); + CommandSync3<T, M, P1, P2, P3> *cmd = allocate_and_lock<CommandSync3<T, M, P1, P2, P3> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -982,20 +1043,20 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4> - void push_and_sync( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4 ) { + template <class T, class M, class P1, class P2, class P3, class P4> + void push_and_sync(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4) { - CommandSync4<T,M,P1,P2,P3,P4> * cmd = allocate_and_lock< CommandSync4<T,M,P1,P2,P3,P4> >(); + CommandSync4<T, M, P1, P2, P3, P4> *cmd = allocate_and_lock<CommandSync4<T, M, P1, P2, P3, P4> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -1003,21 +1064,21 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5> - void push_and_sync( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5> + void push_and_sync(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) { - CommandSync5<T,M,P1,P2,P3,P4,P5> * cmd = allocate_and_lock< CommandSync5<T,M,P1,P2,P3,P4,P5> >(); + CommandSync5<T, M, P1, P2, P3, P4, P5> *cmd = allocate_and_lock<CommandSync5<T, M, P1, P2, P3, P4, P5> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -1025,22 +1086,22 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6> - void push_and_sync( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6> + void push_and_sync(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) { - CommandSync6<T,M,P1,P2,P3,P4,P5,P6> * cmd = allocate_and_lock< CommandSync6<T,M,P1,P2,P3,P4,P5,P6> >(); + CommandSync6<T, M, P1, P2, P3, P4, P5, P6> *cmd = allocate_and_lock<CommandSync6<T, M, P1, P2, P3, P4, P5, P6> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -1048,23 +1109,23 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6,class P7> - void push_and_sync( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,P7 p7 ) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7> + void push_and_sync(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) { - CommandSync7<T,M,P1,P2,P3,P4,P5,P6,P7> * cmd = allocate_and_lock< CommandSync7<T,M,P1,P2,P3,P4,P5,P6,P7> >(); + CommandSync7<T, M, P1, P2, P3, P4, P5, P6, P7> *cmd = allocate_and_lock<CommandSync7<T, M, P1, P2, P3, P4, P5, P6, P7> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; - cmd->p7=p7; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; + cmd->p7 = p7; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -1072,24 +1133,24 @@ public: ss->sem->wait(); } - template<class T, class M, class P1, class P2, class P3, class P4, class P5, class P6,class P7,class P8> - void push_and_sync( T * p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,P7 p7,P8 p8) { + template <class T, class M, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8> + void push_and_sync(T *p_instance, M p_method, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) { - CommandSync8<T,M,P1,P2,P3,P4,P5,P6,P7,P8> * cmd = allocate_and_lock< CommandSync8<T,M,P1,P2,P3,P4,P5,P6,P7,P8> >(); + CommandSync8<T, M, P1, P2, P3, P4, P5, P6, P7, P8> *cmd = allocate_and_lock<CommandSync8<T, M, P1, P2, P3, P4, P5, P6, P7, P8> >(); - cmd->instance=p_instance; - cmd->method=p_method; - cmd->p1=p1; - cmd->p2=p2; - cmd->p3=p3; - cmd->p4=p4; - cmd->p5=p5; - cmd->p6=p6; - cmd->p7=p7; - cmd->p8=p8; + cmd->instance = p_instance; + cmd->method = p_method; + cmd->p1 = p1; + cmd->p2 = p2; + cmd->p3 = p3; + cmd->p4 = p4; + cmd->p5 = p5; + cmd->p6 = p6; + cmd->p7 = p7; + cmd->p8 = p8; - SyncSemaphore *ss=_alloc_sync_sem(); - cmd->sync=ss; + SyncSemaphore *ss = _alloc_sync_sem(); + cmd->sync = ss; unlock(); @@ -1119,7 +1180,6 @@ public: CommandQueueMT(bool p_sync); ~CommandQueueMT(); - }; #endif |