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