csutil/threadmanager.h

00001 /*
00002   Copyright (C) 2008 by Michael Gist
00003 
00004   This library is free software; you can redistribute it and/or
00005   modify it under the terms of the GNU Lesser General Public
00006   License as published by the Free Software Foundation; either
00007   version 2 of the License, or (at your option) any later version.
00008 
00009   This library is distributed in the hope that it will be useful,
00010   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012   Library General Public License for more details.
00013 
00014   You should have received a copy of the GNU Library General Public
00015   License along with this library; if not, write to the Free
00016   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00017 */
00018 
00019 #ifndef __CS_CSUTIL_THREADMANAGER_H__
00020 #define __CS_CSUTIL_THREADMANAGER_H__
00021 
00022 #include "csutil/eventhandlers.h"
00023 #include "csutil/objreg.h"
00024 #include "csutil/threadevent.h"
00025 #include "csutil/threadjobqueue.h"
00026 #include "iengine/engine.h"
00027 #include "imap/loader.h"
00028 #include "iutil/event.h"
00029 #include "iutil/eventh.h"
00030 #include "iutil/eventq.h"
00031 #include "iutil/threadmanager.h"
00032 
00033 struct iEvent;
00034 
00035 class CS_CRYSTALSPACE_EXPORT csThreadManager : public scfImplementation1<csThreadManager,
00036   iThreadManager>
00037 {
00038   class ListAccessQueue : public csRefCount
00039   {
00040   public:
00041     ListAccessQueue();
00042     ~ListAccessQueue();
00043 
00044     void Enqueue(iJob* job, QueueType type);
00045     void ProcessQueue(uint num);
00046     int32 GetQueueCount() const;
00047     void ProcessAll ();
00048   private:
00049     inline void ProcessHighQueue(uint& i, uint& num);
00050     inline void ProcessMedQueue(uint& i, uint& num);
00051     inline void ProcessLowQueue(uint& i, uint& num);
00052 
00053     CS::Threading::RecursiveMutex highQueueLock;
00054     CS::Threading::RecursiveMutex medQueueLock;
00055     CS::Threading::RecursiveMutex lowQueueLock;
00056     csFIFO<csRef<iJob> > highqueue;
00057     csFIFO<csRef<iJob> > medqueue;
00058     csFIFO<csRef<iJob> > lowqueue;
00059     int32 total;
00060   };
00061 public:
00062   csThreadManager(iObjectRegistry* objReg);
00063   virtual ~csThreadManager();
00064   void Init(iConfigManager* config);
00065 
00066   void Process(uint num = 1);
00067   bool Wait(csRefArray<iThreadReturn>& threadReturns, bool process = true);
00068   
00070   void ProcessAll ();
00071 
00072   inline void PushToQueue(QueueType queueType, iJob* job)
00073   {
00074     if(queueType == THREADED || queueType == THREADEDL)
00075     {
00076       CS::Threading::MutexScopedLock lock(waitingThreadsLock);
00077       threadQueue->Enqueue(job);
00078 
00079       for(size_t i=0; i<waitingThreads.GetSize(); ++i)
00080       {
00081         waitingThreads[i]->NotifyAll();
00082       }
00083     }
00084     else
00085     {
00086       {
00087         CS::Threading::MutexScopedLock lock(waitingMainLock);
00088         listQueue->Enqueue(job, queueType);
00089       }
00090       waitingMain.NotifyOne();
00091     }
00092   }
00093 
00094   inline bool RunNow(QueueType queueType, bool wait, bool forceQueue)
00095   {
00096     // True if we're executing something to be run in the main thread,
00097     // and we are the main thread, and we're not forcing it to be put on a queue for later.
00098     bool noThread = alwaysRunNow || (IsMainThread() && queueType != THREADED && queueType != THREADEDL && !forceQueue);
00099 
00100     // True if we're executing something to not be run in the main thread, while all other threads are busy.
00101     bool runNow = noThread || (!forceQueue && (queueType == THREADED || queueType == THREADEDL) && !IsMainThread()
00102       && ((waiting >= threadCount-1) || (threadQueue->GetQueueCount() > 2*threadCount-1) || wait));
00103 
00104     return runNow;
00105   }
00106 
00107   inline int32 GetThreadCount()
00108   {
00109     return threadCount;
00110   }
00111 
00112   inline void SetAlwaysRunNow(bool v)
00113   {
00114     alwaysRunNow = v;
00115   }
00116 
00117   inline bool GetAlwaysRunNow()
00118   {
00119     return alwaysRunNow;
00120   }
00121 
00122   inline bool Exiting()
00123   {
00124     return exiting;
00125   }
00126 
00127 protected:
00128   csEventID ProcessPerFrame;
00129 
00130 private:
00131 
00132   static CS::Threading::ThreadID tid;
00133 
00134   inline bool IsMainThread()
00135   {
00136     return tid == CS::Threading::Thread::GetThreadID();
00137   }
00138 
00139   CS::Threading::Mutex waitingMainLock;
00140   CS::Threading::Condition waitingMain;
00141 
00142   CS::Threading::Mutex waitingThreadsLock;
00143   csArray<CS::Threading::Condition*> waitingThreads;
00144 
00145   int32 waiting;
00146   int32 threadCount;
00147   bool alwaysRunNow;
00148 
00149   iObjectRegistry* objectReg;
00150   csRef<CS::Threading::ThreadedJobQueue> threadQueue;
00151   csRef<ListAccessQueue> listQueue;
00152   csRef<iEventQueue> eventQueue;
00153   csTicks waitingTime;
00154   bool exiting;
00155 
00156   class TMEventHandler : public scfImplementation1<TMEventHandler, 
00157       iEventHandler>
00158   {
00159   public:
00160     TMEventHandler(csThreadManager* parent) :
00161         scfImplementationType (this), parent (parent)
00162     {
00163     }
00164     
00165     virtual ~TMEventHandler()
00166     {
00167     }
00168 
00169     bool HandleEvent(iEvent& Event)
00170     {
00171       if(Event.Name == parent->ProcessPerFrame)
00172       {
00173         if(!parent->alwaysRunNow)
00174         {
00175           parent->Process(5);
00176         }
00177       }
00178       return false;
00179     }
00180 
00181     CS_EVENTHANDLER_PHASE_LOGIC("crystalspace.threadmanager")
00182 
00183   private:
00184     csThreadManager* parent;
00185   };
00186   csRef<iEventHandler> tMEventHandler;
00187 };
00188 
00189 class csThreadReturn : public scfImplementation1<csThreadReturn, iThreadReturn>
00190 {
00191 public:
00192   csThreadReturn(iThreadManager* tm) : scfImplementationType(this),
00193     finished(false), success(false), result(0), tm(tm), waitLock(0),
00194     wait(0)
00195   {
00196   }
00197 
00198   virtual ~csThreadReturn()
00199   {
00200   }
00201 
00202   bool IsFinished()
00203   {
00204     CS::Threading::MutexScopedLock lock(updateLock);
00205     return finished;
00206   }
00207 
00208   bool WasSuccessful()
00209   {
00210     CS::Threading::MutexScopedLock lock(updateLock);
00211     return success;
00212   }
00213 
00214   void* GetResultPtr() { return result; }
00215   csRef<iBase> GetResultRefPtr() { return refResult; }
00216 
00217   void MarkFinished()
00218   {
00219     if(waitLock)
00220       waitLock->Lock();
00221 
00222     {
00223       CS::Threading::MutexScopedLock ulock(updateLock);
00224       finished = true;
00225       if(wait)
00226       {
00227          wait->NotifyAll();
00228       }
00229     }
00230 
00231     if(waitLock)
00232       waitLock->Unlock();
00233   }
00234 
00235   void MarkSuccessful()
00236   {
00237     CS::Threading::MutexScopedLock lock(updateLock);
00238     success = true;
00239   }
00240 
00241   void SetResult(void* result) { this->result = result; }
00242   void SetResult(csRef<iBase> result) { refResult = result; }
00243 
00244   void Copy(iThreadReturn* other)
00245   {
00246     result = other->GetResultPtr();
00247     refResult = other->GetResultRefPtr();
00248     finished = other->IsFinished();
00249   }
00250 
00251   void Wait(bool process = true)
00252   {
00253     csRef<iThreadManager> tm (this->tm.Get<csRef<iThreadManager> >());
00254     if(tm.IsValid())
00255     {
00256       csRefArray<iThreadReturn> rets;
00257       rets.Push(this);
00258       tm->Wait(rets, process);
00259     }
00260   }
00261 
00262   void SetWaitPtrs(CS::Threading::Condition* c, CS::Threading::Mutex* m)
00263   {
00264     CS::Threading::MutexScopedLock lock(updateLock);
00265     wait = c;
00266     waitLock = m;
00267   }
00268 
00269   void SetJob(iJob* j)
00270   {
00271       job = j;
00272   }
00273 
00274   iJob* GetJob() const
00275   {
00276       return job;
00277   }
00278 
00279 private:
00280   bool finished;
00281   bool success;
00282   void* result;
00283   csRef<iBase> refResult;
00284   csWeakRef<iThreadManager> tm;
00285   CS::Threading::Mutex* waitLock;
00286   CS::Threading::Condition* wait;
00287   CS::Threading::Mutex updateLock;
00288   csRef<iJob> job;
00289 };
00290 
00291 template<class T, typename A1, typename A2>
00292 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2), void const** &argsTC, QueueType queueType)
00293 {
00294   csRef<ThreadEvent2<T, A1, A2> > threadEvent;
00295   threadEvent.AttachNew(new ThreadEvent2<T, A1, A2>(object, method, argsTC));
00296   tm->PushToQueue(queueType, threadEvent);
00297   return csPtr<iJob>(threadEvent);
00298 }
00299 
00300 template<class T, typename A1, typename A2, typename A3>
00301 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3), void const** &argsTC, QueueType queueType)
00302 {
00303   csRef<ThreadEvent3<T, A1, A2, A3> > threadEvent;
00304   threadEvent.AttachNew(new ThreadEvent3<T, A1, A2, A3>(object, method, argsTC));
00305   tm->PushToQueue(queueType, threadEvent);
00306   return csPtr<iJob>(threadEvent);
00307 }
00308 
00309 template<class T, typename A1, typename A2, typename A3, typename A4>
00310 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4), void const** &argsTC, QueueType queueType)
00311 {
00312   csRef<ThreadEvent4<T, A1, A2, A3, A4> > threadEvent;
00313   threadEvent.AttachNew(new ThreadEvent4<T, A1, A2, A3, A4>(object, method, argsTC));
00314   tm->PushToQueue(queueType, threadEvent);
00315   return csPtr<iJob>(threadEvent);
00316 }
00317 
00318 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5>
00319 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5), void const** &argsTC, QueueType queueType)
00320 {
00321   csRef<ThreadEvent5<T, A1, A2, A3, A4, A5> > threadEvent;
00322   threadEvent.AttachNew(new ThreadEvent5<T, A1, A2, A3, A4, A5>(object, method, argsTC));
00323   tm->PushToQueue(queueType, threadEvent);
00324   return csPtr<iJob>(threadEvent);
00325 }
00326 
00327 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
00328 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6), void const** &argsTC, QueueType queueType)
00329 {
00330   csRef<ThreadEvent6<T, A1, A2, A3, A4, A5, A6> > threadEvent;
00331   threadEvent.AttachNew(new ThreadEvent6<T, A1, A2, A3, A4, A5, A6>(object, method, argsTC));
00332   tm->PushToQueue(queueType, threadEvent);
00333   return csPtr<iJob>(threadEvent);
00334 }
00335 
00336 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
00337 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7), void const** &argsTC, QueueType queueType)
00338 {
00339   csRef<ThreadEvent7<T, A1, A2, A3, A4, A5, A6, A7> > threadEvent;
00340   threadEvent.AttachNew(new ThreadEvent7<T, A1, A2, A3, A4, A5, A6, A7>(object, method, argsTC));
00341   tm->PushToQueue(queueType, threadEvent);
00342   return csPtr<iJob>(threadEvent);
00343 }
00344 
00345 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
00346 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8), void const** &argsTC, QueueType queueType)
00347 {
00348   csRef<ThreadEvent8<T, A1, A2, A3, A4, A5, A6, A7, A8> > threadEvent;
00349   threadEvent.AttachNew(new ThreadEvent8<T, A1, A2, A3, A4, A5, A6, A7, A8>(object, method, argsTC));
00350   tm->PushToQueue(queueType, threadEvent);
00351   return csPtr<iJob>(threadEvent);
00352 }
00353 
00354 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
00355 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9), void const** &argsTC, QueueType queueType)
00356 {
00357   csRef<ThreadEvent9<T, A1, A2, A3, A4, A5, A6, A7, A8, A9> > threadEvent;
00358   threadEvent.AttachNew(new ThreadEvent9<T, A1, A2, A3, A4, A5, A6, A7, A8, A9>(object, method, argsTC));
00359   tm->PushToQueue(queueType, threadEvent);
00360   return csPtr<iJob>(threadEvent);
00361 }
00362 
00363 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
00364 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), void const** &argsTC, QueueType queueType)
00365 {
00366   csRef<ThreadEvent10<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> > threadEvent;
00367   threadEvent.AttachNew(new ThreadEvent10<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(object, method, argsTC));
00368   tm->PushToQueue(queueType, threadEvent);
00369   return csPtr<iJob>(threadEvent);
00370 }
00371 
00372 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
00373 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), void const** &argsTC, QueueType queueType)
00374 {
00375   csRef<ThreadEvent11<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> > threadEvent;
00376   threadEvent.AttachNew(new ThreadEvent11<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(object, method, argsTC));
00377   tm->PushToQueue(queueType, threadEvent);
00378   return csPtr<iJob>(threadEvent);
00379 }
00380 
00381 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
00382 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), void const** &argsTC, QueueType queueType)
00383 {
00384   csRef<ThreadEvent12<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> > threadEvent;
00385   threadEvent.AttachNew(new ThreadEvent12<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(object, method, argsTC));
00386   tm->PushToQueue(queueType, threadEvent);
00387   return csPtr<iJob>(threadEvent);
00388 }
00389 
00390 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
00391 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), void const** &argsTC, QueueType queueType)
00392 {
00393   csRef<ThreadEvent13<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> > threadEvent;
00394   threadEvent.AttachNew(new ThreadEvent13<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(object, method, argsTC));
00395   tm->PushToQueue(queueType, threadEvent);
00396   return csPtr<iJob>(threadEvent);
00397 }
00398 
00399 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
00400 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), void const** &argsTC, QueueType queueType)
00401 {
00402   csRef<ThreadEvent14<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> > threadEvent;
00403   threadEvent.AttachNew(new ThreadEvent14<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(object, method, argsTC));
00404   tm->PushToQueue(queueType, threadEvent);
00405   return csPtr<iJob>(threadEvent);
00406 }
00407 
00408 template<class T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
00409 csPtr<iJob> QueueEvent(csRef<iThreadManager> tm, ThreadedCallable<T>* object, bool (T::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), void const** &argsTC, QueueType queueType)
00410 {
00411   csRef<ThreadEvent15<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> > threadEvent;
00412   threadEvent.AttachNew(new ThreadEvent15<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(object, method, argsTC));
00413   tm->PushToQueue(queueType, threadEvent);
00414   return csPtr<iJob>(threadEvent);
00415 }
00416 
00417 #define THREADED_CALLABLE_DECL(type, function, returnClass, queueType, wait, forceQueue) \
00418   bool function##TC(csRef<iThreadReturn> ret, bool sync); \
00419   inline csRef<iThreadReturn> function##Wait() \
00420 { \
00421   const type* objTC = const_cast<const type*>(this); \
00422   return objTC->function##Wait(); \
00423 } \
00424   inline csRef<iThreadReturn> function##Wait() const \
00425 { \
00426   return function##T(true); \
00427 } \
00428   inline csRef<iThreadReturn> function() \
00429 { \
00430   const type* objTC = const_cast<const type*>(this); \
00431   return objTC->function(); \
00432 } \
00433   inline csRef<iThreadReturn> function() const \
00434 { \
00435   return function##T(false); \
00436 } \
00437   inline csRef<iThreadReturn> function##T(bool Wait) const \
00438 { \
00439   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00440   csRef<iThreadReturn> ret; \
00441   ret.AttachNew(new returnClass(tm)); \
00442   if(!tm.IsValid() || tm->Exiting()) \
00443   { \
00444     ret->MarkFinished(); \
00445     return ret; \
00446   } \
00447   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00448   { \
00449     type* objTC = const_cast<type*>(this); \
00450     if(objTC->function##TC(ret, Wait || wait)) \
00451     { \
00452       ret->MarkSuccessful(); \
00453     } \
00454     ret->MarkFinished(); \
00455     return ret; \
00456   } \
00457   bool sync = Wait || wait; \
00458   void const** argsTC = new void const*[3]; \
00459   TEventMemPool *mempool = new TEventMemPool; \
00460   argsTC[0] = mempool; \
00461   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00462   argsTC[2] = mempool->Store<bool>(&sync); \
00463   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00464   ret->SetJob(job); \
00465   if(Wait || wait) \
00466   { \
00467     ret->Wait(); \
00468   } \
00469   return ret; \
00470 }
00471 
00472 #define THREADED_CALLABLE_DECL1(type, function, returnClass, T1, A1, queueType, wait, forceQueue) \
00473   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1); \
00474   inline csRef<iThreadReturn> function##Wait(T1 A1) \
00475 { \
00476   const type* objTC = const_cast<const type*>(this); \
00477   return objTC->function##Wait(A1); \
00478 } \
00479   inline csRef<iThreadReturn> function##Wait(T1 A1) const \
00480 { \
00481   return function##T(true, A1); \
00482 } \
00483   inline csRef<iThreadReturn> function(T1 A1) \
00484 { \
00485   const type* objTC = const_cast<const type*>(this); \
00486   return objTC->function(A1); \
00487 } \
00488   inline csRef<iThreadReturn> function(T1 A1) const \
00489 { \
00490   return function##T(false, A1); \
00491 } \
00492   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1) const \
00493 { \
00494   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00495   csRef<iThreadReturn> ret; \
00496   ret.AttachNew(new returnClass(tm)); \
00497   if(!tm.IsValid() || tm->Exiting()) \
00498   { \
00499     ret->MarkFinished(); \
00500     return ret; \
00501   } \
00502   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00503   { \
00504     type* objTC = const_cast<type*>(this); \
00505     if(objTC->function##TC(ret, Wait || wait, A1)) \
00506     { \
00507       ret->MarkSuccessful(); \
00508     } \
00509     ret->MarkFinished(); \
00510     return ret; \
00511   } \
00512   bool sync = Wait || wait; \
00513   void const** argsTC = new void const*[4]; \
00514   TEventMemPool *mempool = new TEventMemPool; \
00515   argsTC[0] = mempool; \
00516   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00517   argsTC[2] = mempool->Store<bool>(&sync); \
00518   argsTC[3] = mempool->Store<T1>(&A1); \
00519   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00520   ret->SetJob(job); \
00521   if(Wait || wait) \
00522   { \
00523     ret->Wait(); \
00524   } \
00525   return ret; \
00526 }
00527 
00528 #define THREADED_CALLABLE_DECL2(type, function, returnClass, T1, A1, T2, A2, queueType, wait, forceQueue) \
00529   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2); \
00530   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2) \
00531 { \
00532   const type* objTC = const_cast<const type*>(this); \
00533   return objTC->function##Wait(A1, A2); \
00534 } \
00535   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2) const \
00536 { \
00537   return function##T(true, A1, A2); \
00538 } \
00539   inline csRef<iThreadReturn> function(T1 A1, T2 A2) \
00540 { \
00541   const type* objTC = const_cast<const type*>(this); \
00542   return objTC->function(A1, A2); \
00543 } \
00544   inline csRef<iThreadReturn> function(T1 A1, T2 A2) const \
00545 { \
00546   return function##T(false, A1, A2); \
00547 } \
00548   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2) const \
00549 { \
00550   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00551   csRef<iThreadReturn> ret; \
00552   ret.AttachNew(new returnClass(tm)); \
00553   if(!tm.IsValid() || tm->Exiting()) \
00554   { \
00555     ret->MarkFinished(); \
00556     return ret; \
00557   } \
00558   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00559   { \
00560     type* objTC = const_cast<type*>(this); \
00561     if(objTC->function##TC(ret, Wait || wait, A1, A2)) \
00562     { \
00563       ret->MarkSuccessful(); \
00564     } \
00565     ret->MarkFinished(); \
00566     return ret; \
00567   } \
00568   bool sync = Wait || wait; \
00569   void const** argsTC = new void const*[5]; \
00570   TEventMemPool *mempool = new TEventMemPool; \
00571   argsTC[0] = mempool; \
00572   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00573   argsTC[2] = mempool->Store<bool>(&sync); \
00574   argsTC[3] = mempool->Store<T1>(&A1); \
00575   argsTC[4] = mempool->Store<T2>(&A2); \
00576   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00577   ret->SetJob(job); \
00578   if(Wait || wait) \
00579   { \
00580     ret->Wait(); \
00581   } \
00582   return ret; \
00583 }
00584 
00585 #define THREADED_CALLABLE_DECL3(type, function, returnClass, T1, A1, T2, A2, T3, A3, queueType, wait, forceQueue) \
00586   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3); \
00587   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3) \
00588 { \
00589   const type* objTC = const_cast<const type*>(this); \
00590   return objTC->function##Wait(A1, A2, A3); \
00591 } \
00592   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3) const \
00593 { \
00594   return function##T(true, A1, A2, A3); \
00595 } \
00596   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3) \
00597 { \
00598   const type* objTC = const_cast<const type*>(this); \
00599   return objTC->function(A1, A2, A3); \
00600 } \
00601   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3) const \
00602 { \
00603   return function##T(false, A1, A2, A3); \
00604 } \
00605   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3) const \
00606 { \
00607   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00608   csRef<iThreadReturn> ret; \
00609   ret.AttachNew(new returnClass(tm)); \
00610   if(!tm.IsValid() || tm->Exiting()) \
00611   { \
00612     ret->MarkFinished(); \
00613     return ret; \
00614   } \
00615   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00616   { \
00617     type* objTC = const_cast<type*>(this); \
00618     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3)) \
00619     { \
00620       ret->MarkSuccessful(); \
00621     } \
00622     ret->MarkFinished(); \
00623     return ret; \
00624   } \
00625   bool sync = Wait || wait; \
00626   void const** argsTC = new void const*[6]; \
00627   TEventMemPool *mempool = new TEventMemPool; \
00628   argsTC[0] = mempool; \
00629   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00630   argsTC[2] = mempool->Store<bool>(&sync); \
00631   argsTC[3] = mempool->Store<T1>(&A1); \
00632   argsTC[4] = mempool->Store<T2>(&A2); \
00633   argsTC[5] = mempool->Store<T3>(&A3); \
00634   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00635   ret->SetJob(job); \
00636   if(Wait || wait) \
00637   { \
00638     ret->Wait(); \
00639   } \
00640   return ret; \
00641 }
00642 
00643 #define THREADED_CALLABLE_DECL4(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, queueType, wait, forceQueue) \
00644   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4); \
00645   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4) \
00646 { \
00647   const type* objTC = const_cast<const type*>(this); \
00648   return objTC->function##Wait(A1, A2, A3, A4); \
00649 } \
00650   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4) const \
00651 { \
00652   return function##T(true, A1, A2, A3, A4); \
00653 } \
00654   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4) \
00655 { \
00656   const type* objTC = const_cast<const type*>(this); \
00657   return objTC->function(A1, A2, A3, A4); \
00658 } \
00659   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4) const \
00660 { \
00661   return function##T(false, A1, A2, A3, A4); \
00662 } \
00663   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4) const \
00664 { \
00665   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00666   csRef<iThreadReturn> ret; \
00667   ret.AttachNew(new returnClass(tm)); \
00668   if(!tm.IsValid() || tm->Exiting()) \
00669   { \
00670     ret->MarkFinished(); \
00671     return ret; \
00672   } \
00673   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00674   { \
00675     type* objTC = const_cast<type*>(this); \
00676     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4)) \
00677     { \
00678       ret->MarkSuccessful(); \
00679     } \
00680     ret->MarkFinished(); \
00681     return ret; \
00682   } \
00683   bool sync = Wait || wait; \
00684   void const** argsTC = new void const*[7]; \
00685   TEventMemPool *mempool = new TEventMemPool; \
00686   argsTC[0] = mempool; \
00687   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00688   argsTC[2] = mempool->Store<bool>(&sync); \
00689   argsTC[3] = mempool->Store<T1>(&A1); \
00690   argsTC[4] = mempool->Store<T2>(&A2); \
00691   argsTC[5] = mempool->Store<T3>(&A3); \
00692   argsTC[6] = mempool->Store<T4>(&A4); \
00693   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00694   ret->SetJob(job); \
00695   if(Wait || wait) \
00696   { \
00697     ret->Wait(); \
00698   } \
00699   return ret; \
00700 }
00701 
00702 #define THREADED_CALLABLE_DECL5(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, queueType, wait, forceQueue) \
00703   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5); \
00704   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5) \
00705 { \
00706   const type* objTC = const_cast<const type*>(this); \
00707   return objTC->function##Wait(A1, A2, A3, A4, A5); \
00708 } \
00709   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5) const \
00710 { \
00711   return function##T(true, A1, A2, A3, A4, A5); \
00712 } \
00713   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5) \
00714 { \
00715   const type* objTC = const_cast<const type*>(this); \
00716   return objTC->function(A1, A2, A3, A4, A5); \
00717 } \
00718   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5) const \
00719 { \
00720   return function##T(false, A1, A2, A3, A4, A5); \
00721 } \
00722   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5) const \
00723 { \
00724   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00725   csRef<iThreadReturn> ret; \
00726   ret.AttachNew(new returnClass(tm)); \
00727   if(!tm.IsValid() || tm->Exiting()) \
00728   { \
00729     ret->MarkFinished(); \
00730     return ret; \
00731   } \
00732   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00733   { \
00734     type* objTC = const_cast<type*>(this); \
00735     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5)) \
00736     { \
00737       ret->MarkSuccessful(); \
00738     } \
00739     ret->MarkFinished(); \
00740     return ret; \
00741   } \
00742   bool sync = Wait || wait; \
00743   void const** argsTC = new void const*[8]; \
00744   TEventMemPool *mempool = new TEventMemPool; \
00745   argsTC[0] = mempool; \
00746   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00747   argsTC[2] = mempool->Store<bool>(&sync); \
00748   argsTC[3] = mempool->Store<T1>(&A1); \
00749   argsTC[4] = mempool->Store<T2>(&A2); \
00750   argsTC[5] = mempool->Store<T3>(&A3); \
00751   argsTC[6] = mempool->Store<T4>(&A4); \
00752   argsTC[7] = mempool->Store<T5>(&A5); \
00753   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00754   ret->SetJob(job); \
00755   if(Wait || wait) \
00756   { \
00757     ret->Wait(); \
00758   } \
00759   return ret; \
00760 }
00761 
00762 #define THREADED_CALLABLE_DECL6(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, queueType, wait, forceQueue) \
00763   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6); \
00764   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6) \
00765 { \
00766   const type* objTC = const_cast<const type*>(this); \
00767   return objTC->function##Wait(A1, A2, A3, A4, A5, A6); \
00768 } \
00769   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6) const \
00770 { \
00771   return function##T(true, A1, A2, A3, A4, A5, A6); \
00772 } \
00773   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6) \
00774 { \
00775   const type* objTC = const_cast<const type*>(this); \
00776   return objTC->function(A1, A2, A3, A4, A5, A6); \
00777 } \
00778   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6) const \
00779 { \
00780   return function##T(false, A1, A2, A3, A4, A5, A6); \
00781 } \
00782   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6) const \
00783 { \
00784   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00785   csRef<iThreadReturn> ret; \
00786   ret.AttachNew(new returnClass(tm)); \
00787   if(!tm.IsValid() || tm->Exiting()) \
00788   { \
00789     ret->MarkFinished(); \
00790     return ret; \
00791   } \
00792   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00793   { \
00794     type* objTC = const_cast<type*>(this); \
00795     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6)) \
00796     { \
00797       ret->MarkSuccessful(); \
00798     } \
00799     ret->MarkFinished(); \
00800     return ret; \
00801   } \
00802   bool sync = Wait || wait; \
00803   void const** argsTC = new void const*[9]; \
00804   TEventMemPool *mempool = new TEventMemPool; \
00805   argsTC[0] = mempool; \
00806   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00807   argsTC[2] = mempool->Store<bool>(&sync); \
00808   argsTC[3] = mempool->Store<T1>(&A1); \
00809   argsTC[4] = mempool->Store<T2>(&A2); \
00810   argsTC[5] = mempool->Store<T3>(&A3); \
00811   argsTC[6] = mempool->Store<T4>(&A4); \
00812   argsTC[7] = mempool->Store<T5>(&A5); \
00813   argsTC[8] = mempool->Store<T6>(&A6); \
00814   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00815   ret->SetJob(job); \
00816   if(Wait || wait) \
00817   { \
00818     ret->Wait(); \
00819   } \
00820   return ret; \
00821 }
00822 
00823 #define THREADED_CALLABLE_DECL7(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, queueType, wait, forceQueue) \
00824   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7); \
00825   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7) \
00826 { \
00827   const type* objTC = const_cast<const type*>(this); \
00828   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7); \
00829 } \
00830   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7) const \
00831 { \
00832   return function##T(true, A1, A2, A3, A4, A5, A6, A7); \
00833 } \
00834   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7) \
00835 { \
00836   const type* objTC = const_cast<const type*>(this); \
00837   return objTC->function(A1, A2, A3, A4, A5, A6, A7); \
00838 } \
00839   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7) const \
00840 { \
00841   return function##T(false, A1, A2, A3, A4, A5, A6, A7); \
00842 } \
00843   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7) const \
00844 { \
00845   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00846   csRef<iThreadReturn> ret; \
00847   ret.AttachNew(new returnClass(tm)); \
00848   if(!tm.IsValid() || tm->Exiting()) \
00849   { \
00850     ret->MarkFinished(); \
00851     return ret; \
00852   } \
00853   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00854   { \
00855     type* objTC = const_cast<type*>(this); \
00856     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7)) \
00857     { \
00858       ret->MarkSuccessful(); \
00859     } \
00860     ret->MarkFinished(); \
00861     return ret; \
00862   } \
00863   bool sync = Wait || wait; \
00864   void const** argsTC = new void const*[10]; \
00865   TEventMemPool *mempool = new TEventMemPool; \
00866   argsTC[0] = mempool; \
00867   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00868   argsTC[2] = mempool->Store<bool>(&sync); \
00869   argsTC[3] = mempool->Store<T1>(&A1); \
00870   argsTC[4] = mempool->Store<T2>(&A2); \
00871   argsTC[5] = mempool->Store<T3>(&A3); \
00872   argsTC[6] = mempool->Store<T4>(&A4); \
00873   argsTC[7] = mempool->Store<T5>(&A5); \
00874   argsTC[8] = mempool->Store<T6>(&A6); \
00875   argsTC[9] = mempool->Store<T7>(&A7); \
00876   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00877   ret->SetJob(job); \
00878   if(Wait || wait) \
00879   { \
00880     ret->Wait(); \
00881   } \
00882   return ret; \
00883 }
00884 
00885 #define THREADED_CALLABLE_DECL8(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, queueType, wait, forceQueue) \
00886   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8); \
00887   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8) \
00888 { \
00889   const type* objTC = const_cast<const type*>(this); \
00890   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8); \
00891 } \
00892   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8) const \
00893 { \
00894   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8); \
00895 } \
00896   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8) \
00897 { \
00898   const type* objTC = const_cast<const type*>(this); \
00899   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8); \
00900 } \
00901   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8) const \
00902 { \
00903   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8); \
00904 } \
00905   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8) const \
00906 { \
00907   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00908   csRef<iThreadReturn> ret; \
00909   ret.AttachNew(new returnClass(tm)); \
00910   if(!tm.IsValid() || tm->Exiting()) \
00911   { \
00912     ret->MarkFinished(); \
00913     return ret; \
00914   } \
00915   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00916   { \
00917     type* objTC = const_cast<type*>(this); \
00918     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8)) \
00919     { \
00920       ret->MarkSuccessful(); \
00921     } \
00922     ret->MarkFinished(); \
00923     return ret; \
00924   } \
00925   bool sync = Wait || wait; \
00926   void const** argsTC = new void const*[11]; \
00927   TEventMemPool *mempool = new TEventMemPool; \
00928   argsTC[0] = mempool; \
00929   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00930   argsTC[2] = mempool->Store<bool>(&sync); \
00931   argsTC[3] = mempool->Store<T1>(&A1); \
00932   argsTC[4] = mempool->Store<T2>(&A2); \
00933   argsTC[5] = mempool->Store<T3>(&A3); \
00934   argsTC[6] = mempool->Store<T4>(&A4); \
00935   argsTC[7] = mempool->Store<T5>(&A5); \
00936   argsTC[8] = mempool->Store<T6>(&A6); \
00937   argsTC[9] = mempool->Store<T7>(&A7); \
00938   argsTC[10] = mempool->Store<T8>(&A8); \
00939   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
00940   ret->SetJob(job); \
00941   if(Wait || wait) \
00942   { \
00943     ret->Wait(); \
00944   } \
00945   return ret; \
00946 }
00947 
00948 #define THREADED_CALLABLE_DECL9(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, T9, A9, queueType, wait, forceQueue) \
00949   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9); \
00950   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9) \
00951 { \
00952   const type* objTC = const_cast<const type*>(this); \
00953   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8, A9); \
00954 } \
00955   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9) const \
00956 { \
00957   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8, A9); \
00958 } \
00959   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9) \
00960 { \
00961   const type* objTC = const_cast<const type*>(this); \
00962   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8, A9); \
00963 } \
00964   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9) const \
00965 { \
00966   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8, A9); \
00967 } \
00968   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9) const \
00969 { \
00970   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
00971   csRef<iThreadReturn> ret; \
00972   ret.AttachNew(new returnClass(tm)); \
00973   if(!tm.IsValid() || tm->Exiting()) \
00974   { \
00975     ret->MarkFinished(); \
00976     return ret; \
00977   } \
00978   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
00979   { \
00980     type* objTC = const_cast<type*>(this); \
00981     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8, A9)) \
00982     { \
00983       ret->MarkSuccessful(); \
00984     } \
00985     ret->MarkFinished(); \
00986     return ret; \
00987   } \
00988   bool sync = Wait || wait; \
00989   void const** argsTC = new void const*[12]; \
00990   TEventMemPool *mempool = new TEventMemPool; \
00991   argsTC[0] = mempool; \
00992   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
00993   argsTC[2] = mempool->Store<bool>(&sync); \
00994   argsTC[3] = mempool->Store<T1>(&A1); \
00995   argsTC[4] = mempool->Store<T2>(&A2); \
00996   argsTC[5] = mempool->Store<T3>(&A3); \
00997   argsTC[6] = mempool->Store<T4>(&A4); \
00998   argsTC[7] = mempool->Store<T5>(&A5); \
00999   argsTC[8] = mempool->Store<T6>(&A6); \
01000   argsTC[9] = mempool->Store<T7>(&A7); \
01001   argsTC[10] = mempool->Store<T8>(&A8); \
01002   argsTC[11] = mempool->Store<T9>(&A9); \
01003   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8, T9>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
01004   ret->SetJob(job); \
01005   if(Wait || wait) \
01006   { \
01007     ret->Wait(); \
01008   } \
01009   return ret; \
01010 }
01011 
01012 #define THREADED_CALLABLE_DECL10(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, T9, A9, T10, A10, queueType, wait, forceQueue) \
01013   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10); \
01014   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10) \
01015 { \
01016   const type* objTC = const_cast<const type*>(this); \
01017   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); \
01018 } \
01019   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10) const \
01020 { \
01021   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); \
01022 } \
01023   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10) \
01024 { \
01025   const type* objTC = const_cast<const type*>(this); \
01026   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); \
01027 } \
01028   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10) const \
01029 { \
01030   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); \
01031 } \
01032   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10) const \
01033 { \
01034   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
01035   csRef<iThreadReturn> ret; \
01036   ret.AttachNew(new returnClass(tm)); \
01037   if(!tm.IsValid() || tm->Exiting()) \
01038   { \
01039     ret->MarkFinished(); \
01040     return ret; \
01041   } \
01042   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
01043   { \
01044     type* objTC = const_cast<type*>(this); \
01045     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) \
01046     { \
01047       ret->MarkSuccessful(); \
01048     } \
01049     ret->MarkFinished(); \
01050     return ret; \
01051   } \
01052   bool sync = Wait || wait; \
01053   void const** argsTC = new void const*[13]; \
01054   TEventMemPool *mempool = new TEventMemPool; \
01055   argsTC[0] = mempool; \
01056   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
01057   argsTC[2] = mempool->Store<bool>(&sync); \
01058   argsTC[3] = mempool->Store<T1>(&A1); \
01059   argsTC[4] = mempool->Store<T2>(&A2); \
01060   argsTC[5] = mempool->Store<T3>(&A3); \
01061   argsTC[6] = mempool->Store<T4>(&A4); \
01062   argsTC[7] = mempool->Store<T5>(&A5); \
01063   argsTC[8] = mempool->Store<T6>(&A6); \
01064   argsTC[9] = mempool->Store<T7>(&A7); \
01065   argsTC[10] = mempool->Store<T8>(&A8); \
01066   argsTC[11] = mempool->Store<T9>(&A9); \
01067   argsTC[12] = mempool->Store<T10>(&A10); \
01068   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
01069   ret->SetJob(job); \
01070   if(Wait || wait) \
01071   { \
01072     ret->Wait(); \
01073   } \
01074   return ret; \
01075 }
01076 
01077 #define THREADED_CALLABLE_DECL11(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, T9, A9, T10, A10, T11, A11, queueType, wait, forceQueue) \
01078   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11); \
01079   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11) \
01080 { \
01081   const type* objTC = const_cast<const type*>(this); \
01082   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11); \
01083 } \
01084   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11) const \
01085 { \
01086   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11); \
01087 } \
01088   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11) \
01089 { \
01090   const type* objTC = const_cast<const type*>(this); \
01091   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11); \
01092 } \
01093   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11) const \
01094 { \
01095   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11); \
01096 } \
01097   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11) const \
01098 { \
01099   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
01100   csRef<iThreadReturn> ret; \
01101   ret.AttachNew(new returnClass(tm)); \
01102   if(!tm.IsValid() || tm->Exiting()) \
01103   { \
01104     ret->MarkFinished(); \
01105     return ret; \
01106   } \
01107   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
01108   { \
01109     type* objTC = const_cast<type*>(this); \
01110     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) \
01111     { \
01112       ret->MarkSuccessful(); \
01113     } \
01114     ret->MarkFinished(); \
01115     return ret; \
01116   } \
01117   bool sync = Wait || wait; \
01118   void const** argsTC = new void const*[14]; \
01119   TEventMemPool *mempool = new TEventMemPool; \
01120   argsTC[0] = mempool; \
01121   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
01122   argsTC[2] = mempool->Store<bool>(&sync); \
01123   argsTC[3] = mempool->Store<T1>(&A1); \
01124   argsTC[4] = mempool->Store<T2>(&A2); \
01125   argsTC[5] = mempool->Store<T3>(&A3); \
01126   argsTC[6] = mempool->Store<T4>(&A4); \
01127   argsTC[7] = mempool->Store<T5>(&A5); \
01128   argsTC[8] = mempool->Store<T6>(&A6); \
01129   argsTC[9] = mempool->Store<T7>(&A7); \
01130   argsTC[10] = mempool->Store<T8>(&A8); \
01131   argsTC[11] = mempool->Store<T9>(&A9); \
01132   argsTC[12] = mempool->Store<T10>(&A10); \
01133   argsTC[13] = mempool->Store<T11>(&A11); \
01134   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
01135   ret->SetJob(job); \
01136   if(Wait || wait) \
01137   { \
01138     ret->Wait(); \
01139   } \
01140   return ret; \
01141 }
01142 
01143 #define THREADED_CALLABLE_DECL12(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, T9, A9, T10, A10, T11, A11, T12, A12, queueType, wait, forceQueue) \
01144   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12); \
01145   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12) \
01146 { \
01147   const type* objTC = const_cast<const type*>(this); \
01148   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12); \
01149 } \
01150   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12) const \
01151 { \
01152   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12); \
01153 } \
01154   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12) \
01155 { \
01156   const type* objTC = const_cast<const type*>(this); \
01157   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12); \
01158 } \
01159   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12) const \
01160 { \
01161   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12); \
01162 } \
01163   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12) const \
01164 { \
01165   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
01166   csRef<iThreadReturn> ret; \
01167   ret.AttachNew(new returnClass(tm)); \
01168   if(!tm.IsValid() || tm->Exiting()) \
01169   { \
01170     ret->MarkFinished(); \
01171     return ret; \
01172   } \
01173   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
01174   { \
01175     type* objTC = const_cast<type*>(this); \
01176     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) \
01177     { \
01178       ret->MarkSuccessful(); \
01179     } \
01180     ret->MarkFinished(); \
01181     return ret; \
01182   } \
01183   bool sync = Wait || wait; \
01184   void const** argsTC = new void const*[15]; \
01185   TEventMemPool *mempool = new TEventMemPool; \
01186   argsTC[0] = mempool; \
01187   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
01188   argsTC[2] = mempool->Store<bool>(&sync); \
01189   argsTC[3] = mempool->Store<T1>(&A1); \
01190   argsTC[4] = mempool->Store<T2>(&A2); \
01191   argsTC[5] = mempool->Store<T3>(&A3); \
01192   argsTC[6] = mempool->Store<T4>(&A4); \
01193   argsTC[7] = mempool->Store<T5>(&A5); \
01194   argsTC[8] = mempool->Store<T6>(&A6); \
01195   argsTC[9] = mempool->Store<T7>(&A7); \
01196   argsTC[10] = mempool->Store<T8>(&A8); \
01197   argsTC[11] = mempool->Store<T9>(&A9); \
01198   argsTC[12] = mempool->Store<T10>(&A10); \
01199   argsTC[13] = mempool->Store<T11>(&A11); \
01200   argsTC[14] = mempool->Store<T12>(&A12); \
01201   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
01202   ret->SetJob(job); \
01203   if(Wait || wait) \
01204   { \
01205     ret->Wait(); \
01206   } \
01207   return ret; \
01208 }
01209 
01210 #define THREADED_CALLABLE_DECL13(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, T9, A9, T10, A10, T11, A11, T12, A12, T13, A13, queueType, wait, forceQueue) \
01211   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13); \
01212   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13) \
01213 { \
01214   const type* objTC = const_cast<const type*>(this); \
01215   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13); \
01216 } \
01217   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13) const \
01218 { \
01219   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13); \
01220 } \
01221   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13) \
01222 { \
01223   const type* objTC = const_cast<const type*>(this); \
01224   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13); \
01225 } \
01226   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13) const \
01227 { \
01228   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13); \
01229 } \
01230   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13) const \
01231 { \
01232   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
01233   csRef<iThreadReturn> ret; \
01234   ret.AttachNew(new returnClass(tm)); \
01235   if(!tm.IsValid() || tm->Exiting()) \
01236   { \
01237     ret->MarkFinished(); \
01238     return ret; \
01239   } \
01240   if(tm->RunNow(queueType, Wait || wait, forceQueue)) \
01241   { \
01242     type* objTC = const_cast<type*>(this); \
01243     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) \
01244     { \
01245       ret->MarkSuccessful(); \
01246     } \
01247     ret->MarkFinished(); \
01248     return ret; \
01249   } \
01250   bool sync = Wait || wait; \
01251   void const** argsTC = new void const*[16]; \
01252   TEventMemPool *mempool = new TEventMemPool; \
01253   argsTC[0] = mempool; \
01254   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(&ret); \
01255   argsTC[2] = mempool->Store<bool>(&sync); \
01256   argsTC[3] = mempool->Store<T1>(&A1); \
01257   argsTC[4] = mempool->Store<T2>(&A2); \
01258   argsTC[5] = mempool->Store<T3>(&A3); \
01259   argsTC[6] = mempool->Store<T4>(&A4); \
01260   argsTC[7] = mempool->Store<T5>(&A5); \
01261   argsTC[8] = mempool->Store<T6>(&A6); \
01262   argsTC[9] = mempool->Store<T7>(&A7); \
01263   argsTC[10] = mempool->Store<T8>(&A8); \
01264   argsTC[11] = mempool->Store<T9>(&A9); \
01265   argsTC[12] = mempool->Store<T10>(&A10); \
01266   argsTC[13] = mempool->Store<T11>(&A11); \
01267   argsTC[14] = mempool->Store<T12>(&A12); \
01268   argsTC[15] = mempool->Store<T13>(&A13); \
01269   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
01270   ret->SetJob(job); \
01271   if(Wait || wait) \
01272   { \
01273     ret->Wait(); \
01274   } \
01275   return ret; \
01276 }
01277 
01278 #define THREADED_CALLABLE_DECL14(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, T9, A9, T10, A10, T11, A11, T12, A12, T13, A13, T14, A14, queueType, wait, forceQueue) \
01279   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14); \
01280   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14) \
01281 { \
01282   const type* objTC = const_cast<const type*>(this); \
01283   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14); \
01284 } \
01285   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14) const \
01286 { \
01287   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14); \
01288 } \
01289   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14) \
01290 { \
01291   const type* objTC = const_cast<const type*>(this); \
01292   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14); \
01293 } \
01294   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14) const \
01295 { \
01296   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14); \
01297 } \
01298   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14) const \
01299 { \
01300   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
01301   csRef<iThreadReturn> ret; \
01302   ret.AttachNew(new returnClass(tm)); \
01303   if(!tm.IsValid() || tm->Exiting()) \
01304   { \
01305     ret->MarkFinished(); \
01306     return ret; \
01307   } \
01308   if(tm->RunNow(queueType, Wait || wait, forceQueue))) \
01309   { \
01310     type* objTC = const_cast<type*>(this); \
01311     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) \
01312     { \
01313       ret->MarkSuccessful(); \
01314     } \
01315     ret->MarkFinished(); \
01316     return ret; \
01317   } \
01318   bool sync = Wait || wait; \
01319   void const** argsTC = new void const*[17]; \
01320   TEventMemPool *mempool = new TEventMemPool; \
01321   argsTC[0] = mempool; \
01322   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(ret); \
01323   argsTC[2] = mempool->Store<bool>(&sync); \
01324   argsTC[3] = mempool->Store<T1>(&A1); \
01325   argsTC[4] = mempool->Store<T2>(&A2); \
01326   argsTC[5] = mempool->Store<T3>(&A3); \
01327   argsTC[6] = mempool->Store<T4>(&A4); \
01328   argsTC[7] = mempool->Store<T5>(&A5); \
01329   argsTC[8] = mempool->Store<T6>(&A6); \
01330   argsTC[9] = mempool->Store<T7>(&A7); \
01331   argsTC[10] = mempool->Store<T8>(&A8); \
01332   argsTC[11] = mempool->Store<T9>(&A9); \
01333   argsTC[12] = mempool->Store<T10>(&A10); \
01334   argsTC[13] = mempool->Store<T11>(&A11); \
01335   argsTC[14] = mempool->Store<T12>(&A12); \
01336   argsTC[15] = mempool->Store<T13>(&A13); \
01337   argsTC[16] = mempool->Store<T14>(&A14); \
01338   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
01339   ret->SetJob(job); \
01340   if(Wait || wait) \
01341   { \
01342     ret->Wait(); \
01343   } \
01344   return ret; \
01345 }
01346 
01347 #define THREADED_CALLABLE_DECL15(type, function, returnClass, T1, A1, T2, A2, T3, A3, T4, A4, T5, A5, T6, A6, T7, A7, T8, A8, T9, A9, T10, A10, T11, A11, T12, A12, T13, A13, T14, A14, T15, A15, queueType, wait, forceQueue) \
01348   bool function##TC(csRef<iThreadReturn> ret, bool sync, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14, T15 A15); \
01349   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14, T15 A15) \
01350 { \
01351   const type* objTC = const_cast<const type*>(this); \
01352   return objTC->function##Wait(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); \
01353 } \
01354   inline csRef<iThreadReturn> function##Wait(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14, T15 A15) const \
01355 { \
01356   return function##T(true, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); \
01357 } \
01358   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14, T15 A15) \
01359 { \
01360   const type* objTC = const_cast<const type*>(this); \
01361   return objTC->function(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); \
01362 } \
01363   inline csRef<iThreadReturn> function(T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14, T15 A15) const \
01364 { \
01365   return function##T(false, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); \
01366 } \
01367   inline csRef<iThreadReturn> function##T(bool Wait, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, T7 A7, T8 A8, T9 A9, T10 A10, T11 A11, T12 A12, T13 A13, T14 A14, T15 A15) const \
01368 { \
01369   csRef<iThreadManager> tm = csQueryRegistry<iThreadManager>(GetObjectRegistry()); \
01370   csRef<iThreadReturn> ret; \
01371   ret.AttachNew(new returnClass(tm)); \
01372   if(!tm.IsValid() || tm->Exiting()) \
01373   { \
01374     ret->MarkFinished(); \
01375     return ret; \
01376   } \
01377   if(tm->RunNow(queueType, Wait || wait, forceQueue))) \
01378   { \
01379     type* objTC = const_cast<type*>(this); \
01380     if(objTC->function##TC(ret, Wait || wait, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)) \
01381     { \
01382       ret->MarkSuccessful(); \
01383     } \
01384     ret->MarkFinished(); \
01385     return ret; \
01386   } \
01387   bool sync = Wait || wait; \
01388   void const** argsTC = new void const*[18]; \
01389   TEventMemPool *mempool = new TEventMemPool; \
01390   argsTC[0] = mempool; \
01391   argsTC[1] = mempool->Store<csRef<iThreadReturn> >(ret); \
01392   argsTC[2] = mempool->Store<bool>(&sync); \
01393   argsTC[3] = mempool->Store<T1>(&A1); \
01394   argsTC[4] = mempool->Store<T2>(&A2); \
01395   argsTC[5] = mempool->Store<T3>(&A3); \
01396   argsTC[6] = mempool->Store<T4>(&A4); \
01397   argsTC[7] = mempool->Store<T5>(&A5); \
01398   argsTC[8] = mempool->Store<T6>(&A6); \
01399   argsTC[9] = mempool->Store<T7>(&A7); \
01400   argsTC[10] = mempool->Store<T8>(&A8); \
01401   argsTC[11] = mempool->Store<T9>(&A9); \
01402   argsTC[12] = mempool->Store<T10>(&A10); \
01403   argsTC[13] = mempool->Store<T11>(&A11); \
01404   argsTC[14] = mempool->Store<T12>(&A12); \
01405   argsTC[15] = mempool->Store<T13>(&A13); \
01406   argsTC[16] = mempool->Store<T14>(&A14); \
01407   argsTC[17] = mempool->Store<T15>(&A15); \
01408   csRef<iJob> job = QueueEvent<type, csRef<iThreadReturn>, bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(tm, (ThreadedCallable<type>*)this, &type::function##TC, argsTC, queueType); \
01409   ret->SetJob(job); \
01410   if(Wait || wait) \
01411   { \
01412     ret->Wait(); \
01413   } \
01414   return ret; \
01415 }
01416 
01417 #define THREADED_CALLABLE_IMPL(type, function) \
01418   bool type::function##TC(csRef<iThreadReturn> ret, bool sync)
01419 
01420 #define THREADED_CALLABLE_IMPL1(type, function, A1) \
01421   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1)
01422 
01423 #define THREADED_CALLABLE_IMPL2(type, function, A1, A2) \
01424   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2)
01425 
01426 #define THREADED_CALLABLE_IMPL3(type, function, A1, A2, A3) \
01427   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3)
01428 
01429 #define THREADED_CALLABLE_IMPL4(type, function, A1, A2, A3, A4) \
01430   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4)
01431 
01432 #define THREADED_CALLABLE_IMPL5(type, function, A1, A2, A3, A4, A5) \
01433   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5)
01434 
01435 #define THREADED_CALLABLE_IMPL6(type, function, A1, A2, A3, A4, A5, A6) \
01436   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6)
01437 
01438 #define THREADED_CALLABLE_IMPL7(type, function, A1, A2, A3, A4, A5, A6, A7) \
01439   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7)
01440 
01441 #define THREADED_CALLABLE_IMPL8(type, function, A1, A2, A3, A4, A5, A6, A7, A8) \
01442   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8)
01443 
01444 #define THREADED_CALLABLE_IMPL9(type, function, A1, A2, A3, A4, A5, A6, A7, A8, A9) \
01445   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8, A9)
01446 
01447 #define THREADED_CALLABLE_IMPL10(type, function, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) \
01448   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)
01449 
01450 #define THREADED_CALLABLE_IMPL11(type, function, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) \
01451   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)
01452 
01453 #define THREADED_CALLABLE_IMPL12(type, function, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) \
01454   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)
01455 
01456 #define THREADED_CALLABLE_IMPL13(type, function, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) \
01457   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)
01458 
01459 #define THREADED_CALLABLE_IMPL14(type, function, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) \
01460   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)
01461 
01462 #define THREADED_CALLABLE_IMPL15(type, function, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) \
01463   bool type::function##TC(csRef<iThreadReturn> ret, bool sync, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)
01464 
01465 #endif // __CS_IUTIL_THREADMANAGER_H__
Generated for Crystal Space 2.1 by doxygen 1.6.1
	Public API Reference
Public API Reference

csutil/threadmanager.h
