CThreadPool Class Reference

#include <ThreadPool.h>

Inheritance diagram for CThreadPool:

Collaboration diagram for CThreadPool:


Classes
struct	_JobData
struct	_ThreadData
Public Types
typedef ThreadPoolProc	LPThreadPoolProc
typedef ThreadDWORDPoolProc	LPThreadDWORDPoolProc
typedef ThreadPoolDataProc	LPThreadPoolDataProc
typedef InitializePoolProc	LPInitializePoolProc
typedef void(*	ThreadPoolProc )(LPVOID pParam)
typedef DWORD(*	ThreadDWORDPoolProc )(LPVOID pParam)
typedef void(*	ThreadPoolDataProc )(LPVOID pParam, LPVOID pThreadData)
typedef BOOL(*	InitializePoolProc )(LPVOID &pParam, BOOL bLoading)
Public Member Functions
int	GetJobsRan () const
void	Clear ()
void	SetExtraDataDrop (BOOL bDrop)
void	SetSleepInterval (DWORD dwSleepInterval)
BOOL	IsInitialized () const
int	GetRunningThreads () const
DWORD	GetMaxThreads () const
BOOL	IsFinished () const
int	GetWaitingJobs () const
BOOL	SubmitJob (LPThreadPoolProc pJobProc, LPVOID lpData)
BOOL	SubmitJob (LPThreadDWORDPoolProc pJobProc, LPVOID lpData)
BOOL	SubmitJob (LPThreadPoolDataProc pJobProc, LPVOID lpData)
	CThreadPool (unsigned long ulNumberOfThreads, unsigned long ulMaxJobsPending=THREAD_POOL_DEFAULT_JOBS, LPInitializePoolProc pInitializeProc=NULL, CGenericThread::ThreadPriority aPriority=CGenericThread::tpNormal, BOOL bInitializeCOM=FALSE)
virtual	~CThreadPool ()
void	SetLocalLog (CErrorLog *pLog)
void	WriteError (const std::string &rClass, const std::string &rMethod, const std::string &rError) const
void	WriteMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage) const
Static Public Member Functions
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	RegisterError (DWORD dwErrorCode, const std::string &rDescription)
static void	SetLog (CErrorLog *pLog)
static void	WriteStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rError)
static std::string	FormatData (const std::string &rClass, const std::string &rMethod, const std::string &rMsgOrError, bool bError=true)
Protected Member Functions
const std::string &	GetClassName () const
virtual void	ReportError (const std::string &rMethod) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, const std::string &rAdditionalData) const
virtual void	ReportError (const std::string &rMethod, int iErrorCode) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, int iErrorCode) const
virtual void	ReportErrorOS (const std::string &rMethod, const std::string &rMessage) const
void	SetName (const std::string &rName) const
Static Protected Member Functions
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData)
static void	ReportStaticErrorOS (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)

Detailed Description

Definition at line 62 of file ThreadPool.h.

Member Typedef Documentation

typedef BOOL(* CThreadPool::InitializePoolProc)(LPVOID &pParam, BOOL bLoading)

typedef InitializePoolProc CThreadPool::LPInitializePoolProc

Definition at line 81 of file ThreadPool.h.

typedef ThreadDWORDPoolProc CThreadPool::LPThreadDWORDPoolProc

Definition at line 71 of file ThreadPool.h.

typedef ThreadPoolDataProc CThreadPool::LPThreadPoolDataProc

Definition at line 76 of file ThreadPool.h.

typedef ThreadPoolProc CThreadPool::LPThreadPoolProc

Definition at line 67 of file ThreadPool.h.

typedef DWORD(* CThreadPool::ThreadDWORDPoolProc)(LPVOID pParam)

typedef void(* CThreadPool::ThreadPoolDataProc)(LPVOID pParam, LPVOID pThreadData)

typedef void(* CThreadPool::ThreadPoolProc)(LPVOID pParam)

Constructor & Destructor Documentation

CThreadPool::CThreadPool	(	unsigned long	ulNumberOfThreads,
		unsigned long	ulMaxJobsPending = `THREAD_POOL_DEFAULT_JOBS`,
		LPInitializePoolProc	pInitializeProc = `NULL`,
		CGenericThread::ThreadPriority	aPriority = `CGenericThread::tpNormal`,
		BOOL	bInitializeCOM = `FALSE`
	)

Definition at line 61 of file ThreadPool.cpp.

00065                                               : CErrorHandler(),
00066                                                 m_ulThreadCount(ulNumberOfThreads),
00067                                                 m_pSemaphore(NULL),
00068                                                 m_ppThreads(NULL),
00069                                                 m_pCSection(NULL),
00070                                                 m_ulJobsCount(0),
00071                                                 m_ppThreadData(NULL),
00072                                                 m_iMaxJobsPending(ulMaxJobsPending),
00073                                                 m_pCSectionCounter(NULL),
00074                                                 m_iRunningThreads(0),
00075                                                 m_bInitialized(FALSE),
00076                                                 m_dwSleepInterval(1),
00077                                                 m_bDrop(FALSE),
00078                                                 m_iTotalJobsRan(0),
00079                                                 m_bInitializeCOM(bInitializeCOM)
00080 {
00081     try
00082     {
00083         //Set our name
00084         SetName(CThreadPool_Class);
00085 
00086         //Check number of threads are legal
00087         if (!ulNumberOfThreads)
00088         {
00089             //Report it
00090             ReportError("CThreadPool","Received zero threads!");
00091 
00092             //Throw and error
00093             throw std::string("Received zero threads!");
00094         }
00095 
00096         //Create the semaphore
00097         m_pSemaphore=COSManager::CreateSemaphore(0,
00098                                                  m_iMaxJobsPending);
00099 
00100         //Create the CS
00101         m_pCSection=COSManager::CreateCriticalSection();
00102         m_pCSectionCounter=COSManager::CreateCriticalSection();
00103 
00104         //Initialize the threads
00105         m_bInitialized=SpawnThreads(pInitializeProc,
00106                                     aPriority,
00107                                     m_bInitializeCOM);
00108     }
00109     ERROR_HANDLER_RETHROW("CThreadPool")
00110 }

CThreadPool::~CThreadPool ( ) [virtual]

Definition at line 112 of file ThreadPool.cpp.

00113 {
00114     try
00115     {
00116         //Clear the threads
00117         ClearThreads();
00118 
00119         //Delete the semaphore
00120         delete m_pSemaphore;
00121         
00122         //Delete the CS
00123         delete m_pCSection;
00124         delete m_pCSectionCounter;
00125     }
00126     ERROR_HANDLER("~CThreadPool")
00127 }

Member Function Documentation

void CThreadPool::Clear ( )

Definition at line 611 of file ThreadPool.cpp.

00612 {
00613     try
00614     {
00615         //Lock the CS
00616         CCriticalAutoRelease aRelease(m_pCSection);
00617 
00618         //Check we can have if
00619         if (!m_ulJobsCount)
00620             return;
00621 
00622         //Delete the data
00623         m_aJobList.clear();
00624         m_ulJobsCount=0;
00625     }
00626     ERROR_HANDLER("Clear")
00627 }

std::string CErrorHandler::ErrorCodeToString ( DWORD dwErrorCode ) [static, inherited]

Definition at line 218 of file ErrorHandler.cpp.

00219 {
00220     try
00221     {
00222         //Try to look it in the errors
00223         if (!CErrorsRepository::GetInstance().GetErrorsMap().empty())
00224         {
00225             //Search
00226             CErrorsRepository::ErrorMap::const_iterator aIterator;
00227             aIterator=CErrorsRepository::GetInstance().GetErrorsMap().find(dwErrorCode);
00228 
00229             //Do we have it
00230             if (aIterator!=CErrorsRepository::GetInstance().GetErrorsMap().end())
00231                 return aIterator->second;
00232         }
00233 
00234         //Get the error string
00235         LPVOID lpMsgBuf;
00236         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
00237                       FORMAT_MESSAGE_FROM_SYSTEM | 
00238                       FORMAT_MESSAGE_IGNORE_INSERTS,
00239                       NULL,
00240                       dwErrorCode,
00241                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
00242                       (LPTSTR) &lpMsgBuf,
00243                       0,
00244                       NULL);
00245 
00246         //Save it
00247         std::string sMessage;
00248 
00249         //Do we have the message?
00250         if (lpMsgBuf)
00251         {
00252             //Save it
00253             sMessage=(char*)lpMsgBuf;
00254             
00255             //Release the buffer
00256             LocalFree(lpMsgBuf);
00257         }
00258         else
00259             //Failed to find
00260             sMessage="No error description found!";
00261 
00262         //Done
00263         return sMessage;
00264     }
00265     catch (...)
00266     {
00267         return "Unknown";
00268     }
00269 }

std::string CErrorHandler::FormatData	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMsgOrError,
		bool	bError = `true`
	)			`[static, inherited]`

Definition at line 140 of file ErrorHandler.cpp.

00144 {
00145     //Our message
00146     std::string sMsg;
00147 
00148     //Is it an error?
00149     if (bError)
00150         sMsg="*** Error *** ";
00151     else
00152         sMsg="###  Msg  ### ";
00153 
00154     //Add the data now
00155     sMsg+="in "+rClass;
00156     sMsg+=":"+rMethod;
00157     sMsg+=" - " + rMsgOrError;
00158 
00159     //Done
00160     return sMsg;
00161 }

const std::string & CErrorHandler::GetClassName ( ) const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 567 of file ErrorHandler.cpp.

00568 {
00569     return m_sClassName;
00570 }

std::string CErrorHandler::GetCurrentDateTime ( ) [static, inherited]

Definition at line 572 of file ErrorHandler.cpp.

00573 {
00574     try
00575     {
00576         //Our string
00577         std::string sDate;
00578 
00579         //Our tmp buf
00580         char cTmp[128];
00581 
00582         //Get date
00583         _strdate(cTmp);
00584         sDate=cTmp;
00585         sDate+=' ';
00586 
00587         //Get time
00588         _strtime(cTmp);
00589         sDate+=cTmp;
00590 
00591         //Done
00592         return sDate;
00593     }
00594     ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","")
00595 }

int CThreadPool::GetJobsRan ( ) const

Definition at line 629 of file ThreadPool.cpp.

00630 {
00631     return m_iTotalJobsRan;
00632 }

DWORD CThreadPool::GetMaxThreads ( ) const

Definition at line 586 of file ThreadPool.cpp.

00587 {
00588     return m_ulThreadCount;
00589 }

int CThreadPool::GetRunningThreads ( ) const

Definition at line 606 of file ThreadPool.cpp.

00607 {
00608     return m_iRunningThreads;
00609 }

int CThreadPool::GetWaitingJobs ( ) const

Definition at line 546 of file ThreadPool.cpp.

00547 {
00548     try
00549     {
00550         //Lock the CS
00551         CCriticalAutoRelease aRelease(m_pCSection);
00552 
00553         //Save the number of jobs
00554         int iJobs;
00555         iJobs=m_ulJobsCount;
00556 
00557         //And return it
00558         return iJobs;
00559     }
00560     ERROR_HANDLER_RETURN("GetWaitingJobs",0)
00561 }

BOOL CThreadPool::IsFinished ( ) const

Definition at line 580 of file ThreadPool.cpp.

00581 {
00582     return !m_ulJobsCount && 
00583            !m_iRunningThreads;
00584 }

BOOL CThreadPool::IsInitialized ( ) const

Definition at line 591 of file ThreadPool.cpp.

00592 {
00593     return m_bInitialized;
00594 }

void CErrorHandler::RegisterError	(	DWORD	dwErrorCode,
		const std::string &	rDescription
	)			`[static, inherited]`

Definition at line 597 of file ErrorHandler.cpp.

00599 {
00600     try
00601     {
00602         //Add the error
00603         CErrorsRepository::GetInstance().GetErrorsMap().insert(CErrorsRepository::ErrorMap::value_type(dwErrorCode,rDescription));
00604     }
00605     ERROR_HANDLER_STATIC(CErrorHandler_Class,"RegisterError")
00606 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		int	iErrorCode
	)			const `[protected, virtual, inherited]`

Definition at line 271 of file ErrorHandler.cpp.

00274 {
00275     if (!GetLog())
00276         return;
00277 
00278     try
00279     {
00280         //Convert the error code
00281         char aTmp[11];
00282         sprintf(aTmp,"%d",iErrorCode);
00283 
00284         //Get the string for it
00285         std::string sError;
00286         sError=rMessage;
00287         sError+=", and Socket error: ";
00288         sError+=aTmp;
00289         sError+=", ";
00290         sError+=ErrorCodeToString(iErrorCode);
00291 
00292         //Report to the log
00293         WriteError(m_sClassName,
00294                    rMethod,
00295                    sError);
00296     }
00297     ERROR_UNKNOWN("ReportError")
00298 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		int	iErrorCode
	)			const `[protected, virtual, inherited]`

Definition at line 300 of file ErrorHandler.cpp.

00302 {
00303     if (!GetLog())
00304         return;
00305 
00306     try
00307     {
00308         //Convert the error code
00309         char aTmp[11];
00310         sprintf(aTmp,"%d",iErrorCode);
00311 
00312         //Get the string for it
00313         std::string sError;
00314         sError="Socket error: ";
00315         sError+=aTmp;
00316         sError+=", ";
00317         sError+=ErrorCodeToString(iErrorCode);
00318 
00319         //Report to the log
00320         WriteError(m_sClassName,
00321                    rMethod,
00322                    sError);
00323     }
00324     ERROR_UNKNOWN("ReportError")
00325 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		const std::string &	rAdditionalData
	)			const `[protected, virtual, inherited]`

Definition at line 416 of file ErrorHandler.cpp.

00419 {
00420     if (!GetLog())
00421         return;
00422 
00423     try
00424     {
00425         //Create the new message
00426         std::string sNewMessage(rMessage);
00427         sNewMessage+=", Additional data: ";
00428         sNewMessage+=rAdditionalData;
00429 
00430         //Report to the log
00431         WriteError(m_sClassName,
00432                    rMethod,
00433                    sNewMessage);
00434     }
00435     ERROR_UNKNOWN("ReportError")
00436 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			const `[protected, virtual, inherited]`

Definition at line 438 of file ErrorHandler.cpp.

00441 {
00442     if (!GetLog())
00443         return;
00444 
00445     try
00446     {
00447         //Convert the number
00448         char aTmp[11];
00449         ltoa(dwAdditionalData,aTmp,10);
00450 
00451         //Create the new message
00452         std::string sNewMessage(rMessage);
00453         sNewMessage+=", Additional data: ";
00454         sNewMessage+=aTmp;
00455 
00456         //Report to the log
00457         WriteError(m_sClassName,
00458                    rMethod,
00459                    sNewMessage);
00460     }
00461     ERROR_UNKNOWN("ReportError")
00462 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[protected, virtual, inherited]`

Definition at line 327 of file ErrorHandler.cpp.

00329 {
00330     if (!GetLog())
00331         return;
00332 
00333     try
00334     {
00335         //Report to the log
00336         WriteError(m_sClassName,
00337                    rMethod,
00338                    rMessage);
00339     }
00340     ERROR_UNKNOWN("ReportError")
00341 }

void CErrorHandler::ReportError ( const std::string & rMethod ) const [protected, virtual, inherited]

Definition at line 470 of file ErrorHandler.cpp.

00471 {
00472     if (!GetLog())
00473         return;
00474 
00475     try
00476     {
00477         //Get the last error
00478         DWORD dwLastError;
00479         dwLastError=GetLastError();
00480 
00481         //Report the error
00482         WriteError(m_sClassName,
00483                    rMethod,
00484                    ErrorCodeToString(dwLastError));
00485     }
00486     ERROR_UNKNOWN("ReportError")
00487 }

void CErrorHandler::ReportErrorOS	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[protected, virtual, inherited]`

Definition at line 378 of file ErrorHandler.cpp.

00380 {
00381     if (!GetLog())
00382         return;
00383 
00384     try
00385     {
00386         //Get the last error
00387         DWORD dwLastError;
00388         dwLastError=GetLastError();
00389 
00390         //Format the message
00391         std::string sMessage;
00392         sMessage=rMessage;
00393         sMessage+=", with error code: ";
00394 
00395         //Convert the error code
00396         char aTmp[11];
00397         itoa(dwLastError,aTmp,10);
00398 
00399         //Add it again
00400         sMessage+=aTmp;
00401         sMessage+=" ";
00402         sMessage+=ErrorCodeToString(dwLastError);
00403         
00404         //Get the log
00405         CErrorLog* pLog;
00406         pLog=GetLog();
00407 
00408         //Report to the log
00409         WriteError(m_sClassName,
00410                    rMethod,
00411                    sMessage);
00412     }
00413     ERROR_UNKNOWN("ReportErrorOS")
00414 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			`[static, protected, inherited]`

Definition at line 540 of file ErrorHandler.cpp.

00544 {
00545     if (!m_pLog)
00546         return;
00547 
00548     try
00549     {
00550         //Convert the number
00551         char aTmp[11];
00552         ltoa(dwAdditionalData,aTmp,10);
00553 
00554         //Create the new message
00555         std::string sNewMessage(rMessage);
00556         sNewMessage+=", Additional data: ";
00557         sNewMessage+=aTmp;
00558 
00559         //Report to the log
00560         WriteStaticError(rClass,
00561                          rMethod,
00562                          sNewMessage);
00563     }
00564     ERROR_UNKNOWN("ReportStaticError")
00565 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			`[static, protected, inherited]`

Definition at line 523 of file ErrorHandler.cpp.

00526 {
00527     if (!m_pLog)
00528         return;
00529 
00530     try
00531     {
00532         //Report to the log
00533         WriteStaticError(rClass,
00534                          rMethod,
00535                          rMessage);
00536     }
00537     ERROR_UNKNOWN("ReportStaticError")
00538 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod
	)			`[static, protected, inherited]`

Definition at line 503 of file ErrorHandler.cpp.

00505 {
00506     if (!m_pLog)
00507         return;
00508 
00509     try
00510     {
00511         //Get the last error
00512         DWORD dwLastError;
00513         dwLastError=GetLastError();
00514 
00515         //Report the error
00516         WriteStaticError(rClass,
00517                           rMethod,
00518                           ErrorCodeToString(dwLastError));
00519     }
00520     ERROR_UNKNOWN("ReportStaticError")
00521 }

void CErrorHandler::ReportStaticErrorOS	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			`[static, protected, inherited]`

Definition at line 343 of file ErrorHandler.cpp.

00346 {
00347     if (!m_pLog)
00348         return;
00349 
00350     try
00351     {
00352         //Get the last error
00353         DWORD dwLastError;
00354         dwLastError=GetLastError();
00355 
00356         //Format the message
00357         std::string sMessage;
00358         sMessage=rMessage;
00359         sMessage+=", with error code: ";
00360 
00361         //Convert the error code
00362         char aTmp[11];
00363         itoa(dwLastError,aTmp,10);
00364 
00365         //Add it again
00366         sMessage+=aTmp;
00367         sMessage+=" ";
00368         sMessage+=ErrorCodeToString(dwLastError);
00369         
00370         //Report to the log
00371         WriteStaticError(rClass,
00372                          rMethod,
00373                          sMessage);
00374     }
00375     ERROR_UNKNOWN("ReportStaticError")
00376 }

void CThreadPool::SetExtraDataDrop ( BOOL bDrop )

Definition at line 601 of file ThreadPool.cpp.

00602 {
00603     m_bDrop=bDrop;
00604 }

void CErrorHandler::SetLocalLog ( CErrorLog * pLog ) [inherited]

Definition at line 498 of file ErrorHandler.cpp.

00499 {
00500     m_pLocalLog=pLog;
00501 }

void CErrorHandler::SetLog ( CErrorLog * pLog ) [static, inherited]

Definition at line 464 of file ErrorHandler.cpp.

00465 {
00466     //Save the new log
00467     m_pLog=pLog;
00468 }

void CErrorHandler::SetName ( const std::string & rName ) const [protected, inherited]

Definition at line 134 of file ErrorHandler.cpp.

00135 {
00136     //Save the class name
00137     m_sClassName=rName;
00138 }

void CThreadPool::SetSleepInterval ( DWORD dwSleepInterval )

Definition at line 596 of file ThreadPool.cpp.

00597 {
00598     m_dwSleepInterval=dwSleepInterval;
00599 }

BOOL CThreadPool::SubmitJob	(	LPThreadPoolDataProc	pJobProc,
		LPVOID	lpData
	)

Definition at line 241 of file ThreadPool.cpp.

00243 {
00244     try
00245     {
00246         return SubmitJob(NULL,
00247                          NULL,
00248                          pJobProc,
00249                          lpData);
00250     }
00251     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00252 }

BOOL CThreadPool::SubmitJob	(	LPThreadDWORDPoolProc	pJobProc,
		LPVOID	lpData
	)

Definition at line 228 of file ThreadPool.cpp.

00230 {
00231     try
00232     {
00233         return SubmitJob(NULL,
00234                          pJobProc,
00235                          NULL,
00236                          lpData);
00237     }
00238     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00239 }

BOOL CThreadPool::SubmitJob	(	LPThreadPoolProc	pJobProc,
		LPVOID	lpData
	)

Definition at line 215 of file ThreadPool.cpp.

00217 {
00218     try
00219     {
00220         return SubmitJob(pJobProc,
00221                          NULL,
00222                          NULL,
00223                          lpData);
00224     }
00225     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00226 }

void CErrorHandler::WriteError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rError
	)			const `[inherited]`

Definition at line 163 of file ErrorHandler.cpp.

00166 {
00167     //Do we have a log?
00168     if (!GetLog())
00169         return;
00170 
00171     //Format the msg
00172     std::string sError;
00173     sError=FormatData(rClass,
00174                       rMethod,
00175                       rError);
00176 
00177     //Write it
00178     GetLog()->WriteError(sError);
00179 }

void CErrorHandler::WriteMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[inherited]`

Definition at line 199 of file ErrorHandler.cpp.

00202 {
00203     //Do we have a log?
00204     if (!GetLog())
00205         return;
00206 
00207     //Format the msg
00208     std::string sMsg;
00209     sMsg=FormatData(rClass,
00210                     rMethod,
00211                     rMessage,
00212                     true);
00213 
00214     //Write it
00215     GetLog()->WriteMessage(sMsg);
00216 }

void CErrorHandler::WriteStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rError
	)			`[static, inherited]`

Definition at line 181 of file ErrorHandler.cpp.

00184 {
00185     //Do we have a log?
00186     if (!m_pLog)
00187         return;
00188 
00189     //Format the msg
00190     std::string sError;
00191     sError=FormatData(rClass,
00192                       rMethod,
00193                       rError);
00194 
00195     //Write it
00196     m_pLog->WriteError(sError);
00197 }

The documentation for this class was generated from the following files:

Retail products

Documentation

CThreadPool Class Reference

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation