CThreadPool Class Reference

#include <ThreadPool.h>

Inheritance diagram for CThreadPool:

Collaboration diagram for CThreadPool:


Classes
struct	_JobData
struct	_ThreadData
Public Types
enum	_COMInit { ciNone, ciSingle, ciApartment, ciMulti }
typedef enum CThreadPool::_COMInit	COMInit
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
void	SetPoolName (const std::string &rName)
void	SetTimeout (DWORD dwTimeout)
DWORD	GetTimeout () const
void	FastStop ()
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, COMInit bInitializeCOM=ciNone)
virtual	~CThreadPool ()
void	SetLocalLog (CErrorLog *pLog, bool bWriteToMain=false)
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 CErrorHandler *	GetSecondaryLog ()
static CErrorHandler *	GetThirdLog ()
static void	ClearStaticLogs ()
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 void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static std::string	FormatData (const std::string &rClass, const std::string &rMethod, const std::string &rMsgOrError, bool bError=true)
Protected Member Functions
void	WriteMessage (const std::string &rMethod, const std::string &rMessage) const
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 63 of file ThreadPool.h.

Member Typedef Documentation

typedef enum CThreadPool::_COMInit CThreadPool::COMInit

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

typedef InitializePoolProc CThreadPool::LPInitializePoolProc

Definition at line 91 of file ThreadPool.h.

typedef ThreadDWORDPoolProc CThreadPool::LPThreadDWORDPoolProc

Definition at line 81 of file ThreadPool.h.

typedef ThreadPoolDataProc CThreadPool::LPThreadPoolDataProc

Definition at line 86 of file ThreadPool.h.

typedef ThreadPoolProc CThreadPool::LPThreadPoolProc

Definition at line 77 of file ThreadPool.h.

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

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

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

Member Enumeration Documentation

enum CThreadPool::_COMInit

Enumerator:

ciNone
ciSingle
ciApartment
ciMulti

Definition at line 67 of file ThreadPool.h.

00068     {
00069         ciNone,
00070         ciSingle,
00071         ciApartment,
00072         ciMulti
00073     } COMInit;

Constructor & Destructor Documentation

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

Definition at line 194 of file ThreadPool.cpp.

00198                                                  : CErrorHandler(),
00199                                                    m_ulThreadCount(ulNumberOfThreads),
00200                                                    m_pSemaphore(NULL),
00201                                                    m_ppThreads(NULL),
00202                                                    m_pCSection(NULL),
00203                                                    m_ulJobsCount(0),
00204                                                    m_ppThreadData(NULL),
00205                                                    m_iMaxJobsPending(ulMaxJobsPending),
00206                                                    m_pCSectionCounter(NULL),
00207                                                    m_iRunningThreads(0),
00208                                                    m_bInitialized(FALSE),
00209                                                    m_dwSleepInterval(1),
00210                                                    m_bDrop(FALSE),
00211                                                    m_iTotalJobsRan(0),
00212                                                    m_bInitializeCOM(bInitializeCOM),
00213                                                    m_dwTimeout(0)
00214 {
00215     try
00216     {
00217         //Set our name
00218         SetName(CThreadPool_Class);
00219 
00220         //Check number of threads are legal
00221         if (!ulNumberOfThreads)
00222         {
00223             //Report it
00224             ReportError("CThreadPool","Received zero threads!");
00225 
00226             //Throw and error
00227             throw std::string("Received zero threads!");
00228         }
00229 
00230         //Create the semaphore
00231         m_pSemaphore=COSManager::CreateSemaphore(0,
00232                                                  m_iMaxJobsPending);
00233 
00234         //Create the CS
00235         m_pCSection=COSManager::CreateCriticalSection();
00236         m_pCSectionCounter=COSManager::CreateCriticalSection();
00237 
00238         //Initialize the threads
00239         m_bInitialized=SpawnThreads(pInitializeProc,
00240                                     aPriority,
00241                                     m_bInitializeCOM);
00242     }
00243     ERROR_HANDLER_RETHROW("CThreadPool")
00244 }

CThreadPool::~CThreadPool ( ) [virtual]

Definition at line 246 of file ThreadPool.cpp.

00247 {
00248     try
00249     {
00250         //Clear the threads
00251         ClearThreads();
00252 
00253         //Delete the semaphore
00254         delete m_pSemaphore;
00255         
00256         //Delete the CS
00257         delete m_pCSection;
00258         delete m_pCSectionCounter;
00259     }
00260     ERROR_HANDLER("~CThreadPool")
00261 }

Member Function Documentation

void CThreadPool::Clear ( )

Definition at line 832 of file ThreadPool.cpp.

00833 {
00834     try
00835     {
00836         //Lock the CS
00837         CCriticalAutoRelease aRelease(m_pCSection);
00838 
00839         //Check we can have if
00840         if (!m_ulJobsCount)
00841             return;
00842 
00843         //Delete the data
00844         m_aJobList.clear();
00845         m_ulJobsCount=0;
00846     }
00847     ERROR_HANDLER("Clear")
00848 }

void CErrorHandler::ClearStaticLogs ( ) [static, inherited]

Definition at line 680 of file ErrorHandler.cpp.

00681 {
00682     //Delete the logs
00683     delete m_pSecondLevelLog;
00684     m_pSecondLevelLog=NULL;
00685 
00686     delete m_pThirdLevelLog;
00687     m_pThirdLevelLog=NULL;
00688 }

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

Definition at line 251 of file ErrorHandler.cpp.

00252 {
00253     try
00254     {
00255         //Try to look it in the errors
00256         if (!CErrorsRepository::GetInstance().GetErrorsMap().empty())
00257         {
00258             //Search
00259             CErrorsRepository::ErrorMap::const_iterator aIterator;
00260             aIterator=CErrorsRepository::GetInstance().GetErrorsMap().find(dwErrorCode);
00261 
00262             //Do we have it
00263             if (aIterator!=CErrorsRepository::GetInstance().GetErrorsMap().end())
00264                 return aIterator->second;
00265         }
00266 
00267         //Get the error string
00268         LPVOID lpMsgBuf;
00269         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
00270                       FORMAT_MESSAGE_FROM_SYSTEM | 
00271                       FORMAT_MESSAGE_IGNORE_INSERTS,
00272                       NULL,
00273                       dwErrorCode,
00274                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
00275                       (LPTSTR) &lpMsgBuf,
00276                       0,
00277                       NULL);
00278 
00279         //Save it
00280         std::string sMessage;
00281 
00282         //Do we have the message?
00283         if (lpMsgBuf)
00284         {
00285             //Save it
00286             sMessage=(char*)lpMsgBuf;
00287             
00288             //Release the buffer
00289             LocalFree(lpMsgBuf);
00290         }
00291         else
00292             //Failed to find
00293             sMessage="No error description found!";
00294 
00295         //Done
00296         return sMessage;
00297     }
00298     catch (...)
00299     {
00300         return "Unknown";
00301     }
00302 }

void CThreadPool::FastStop ( )

Definition at line 648 of file ThreadPool.cpp.

00649 {
00650     try
00651     {
00652         //Clear all jobs
00653         Clear();
00654 
00655         //Clear the threads
00656         ClearThreads(true);
00657     }
00658     ERROR_HANDLER("FastStop")
00659 }

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

Definition at line 145 of file ErrorHandler.cpp.

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

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

Reimplemented in CSocketThreadManager.

Definition at line 617 of file ErrorHandler.cpp.

00618 {
00619     return m_sClassName;
00620 }

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

Definition at line 622 of file ErrorHandler.cpp.

00623 {
00624     try
00625     {
00626         //Our string
00627         std::string sDate;
00628 
00629         //Our tmp buf
00630         char cTmp[128];
00631 
00632         //Get date
00633         _strdate(cTmp);
00634         sDate=cTmp;
00635         sDate+=' ';
00636 
00637         //Get time
00638         _strtime(cTmp);
00639         sDate+=cTmp;
00640 
00641         //Done
00642         return sDate;
00643     }
00644     ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","")
00645 }

int CThreadPool::GetJobsRan ( ) const

Definition at line 850 of file ThreadPool.cpp.

00851 {
00852     return m_iTotalJobsRan;
00853 }

DWORD CThreadPool::GetMaxThreads ( ) const

Definition at line 807 of file ThreadPool.cpp.

00808 {
00809     return m_ulThreadCount;
00810 }

int CThreadPool::GetRunningThreads ( ) const

Definition at line 827 of file ThreadPool.cpp.

00828 {
00829     return m_iRunningThreads;
00830 }

CErrorHandler * CErrorHandler::GetSecondaryLog ( ) [static, inherited]

Definition at line 658 of file ErrorHandler.cpp.

00659 {
00660     //Do we have log
00661     if (!m_pSecondLevelLog)
00662         //Create it
00663         m_pSecondLevelLog=new CErrorHandler;
00664 
00665     //Return it
00666     return m_pSecondLevelLog;
00667 }

CErrorHandler * CErrorHandler::GetThirdLog ( ) [static, inherited]

Definition at line 669 of file ErrorHandler.cpp.

00670 {
00671     //Do we have log
00672     if (!m_pThirdLevelLog)
00673         //Create it
00674         m_pThirdLevelLog=new CErrorHandler;
00675 
00676     //Return it
00677     return m_pThirdLevelLog;
00678 }

DWORD CThreadPool::GetTimeout ( ) const

Definition at line 268 of file ThreadPool.cpp.

00269 {
00270     return m_dwTimeout;
00271 }

int CThreadPool::GetWaitingJobs ( ) const

Definition at line 770 of file ThreadPool.cpp.

00771 {
00772     try
00773     {
00774         //Save the number of jobs
00775         int iJobs;
00776         iJobs=m_ulJobsCount;
00777 
00778         //And return it
00779         return iJobs;
00780     }
00781     ERROR_HANDLER_RETURN("GetWaitingJobs",0)
00782 }

BOOL CThreadPool::IsFinished ( ) const

Definition at line 801 of file ThreadPool.cpp.

00802 {
00803     return !m_ulJobsCount && 
00804            !m_iRunningThreads;
00805 }

BOOL CThreadPool::IsInitialized ( ) const

Definition at line 812 of file ThreadPool.cpp.

00813 {
00814     return m_bInitialized;
00815 }

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

Definition at line 647 of file ErrorHandler.cpp.

00649 {
00650     try
00651     {
00652         //Add the error
00653         CErrorsRepository::GetInstance().GetErrorsMap().insert(CErrorsRepository::ErrorMap::value_type(dwErrorCode,rDescription));
00654     }
00655     ERROR_HANDLER_STATIC(CErrorHandler_Class,"RegisterError")
00656 }

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

Definition at line 304 of file ErrorHandler.cpp.

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

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

Definition at line 333 of file ErrorHandler.cpp.

00335 {
00336     if (!GetLog())
00337         return;
00338 
00339     try
00340     {
00341         //Convert the error code
00342         char aTmp[11];
00343         sprintf(aTmp,"%d",iErrorCode);
00344 
00345         //Get the string for it
00346         std::string sError;
00347         sError="Socket error: ";
00348         sError+=aTmp;
00349         sError+=", ";
00350         sError+=ErrorCodeToString(iErrorCode);
00351 
00352         //Report to the log
00353         WriteError(m_sClassName,
00354                    rMethod,
00355                    sError);
00356     }
00357     ERROR_UNKNOWN("ReportError")
00358 }

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

Definition at line 461 of file ErrorHandler.cpp.

00464 {
00465     if (!GetLog())
00466         return;
00467 
00468     try
00469     {
00470         //Create the new message
00471         std::string sNewMessage(rMessage);
00472         sNewMessage+=", Additional data: ";
00473         sNewMessage+=rAdditionalData;
00474 
00475         //Report to the log
00476         WriteError(m_sClassName,
00477                    rMethod,
00478                    sNewMessage);
00479     }
00480     ERROR_UNKNOWN("ReportError")
00481 }

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

Definition at line 483 of file ErrorHandler.cpp.

00486 {
00487     if (!GetLog())
00488         return;
00489 
00490     try
00491     {
00492         //Convert the number
00493         char aTmp[11];
00494         ltoa(dwAdditionalData,aTmp,10);
00495 
00496         //Create the new message
00497         std::string sNewMessage(rMessage);
00498         sNewMessage+=", Additional data: ";
00499         sNewMessage+=aTmp;
00500 
00501         //Report to the log
00502         WriteError(m_sClassName,
00503                    rMethod,
00504                    sNewMessage);
00505     }
00506     ERROR_UNKNOWN("ReportError")
00507 }

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

Definition at line 376 of file ErrorHandler.cpp.

00378 {
00379     if (!GetLog())
00380         return;
00381 
00382     try
00383     {
00384         //Report to the log
00385         WriteError(m_sClassName,
00386                    rMethod,
00387                    rMessage);
00388     }
00389     ERROR_UNKNOWN("ReportError")
00390 }

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

Definition at line 515 of file ErrorHandler.cpp.

00516 {
00517     if (!GetLog())
00518         return;
00519 
00520     try
00521     {
00522         //Get the last error
00523         DWORD dwLastError;
00524         dwLastError=GetLastError();
00525 
00526         //Report the error
00527         WriteError(m_sClassName,
00528                    rMethod,
00529                    ErrorCodeToString(dwLastError));
00530     }
00531     ERROR_UNKNOWN("ReportError")
00532 }

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

Definition at line 427 of file ErrorHandler.cpp.

00429 {
00430     if (!GetLog())
00431         return;
00432 
00433     try
00434     {
00435         //Get the last error
00436         DWORD dwLastError;
00437         dwLastError=GetLastError();
00438 
00439         //Format the message
00440         std::string sMessage;
00441         sMessage=rMessage;
00442         sMessage+=", with error code: ";
00443 
00444         //Convert the error code
00445         char aTmp[11];
00446         itoa(dwLastError,aTmp,10);
00447 
00448         //Add it again
00449         sMessage+=aTmp;
00450         sMessage+=" ";
00451         sMessage+=ErrorCodeToString(dwLastError);
00452 
00453         //Report to the log
00454         WriteError(m_sClassName,
00455                    rMethod,
00456                    sMessage);
00457     }
00458     ERROR_UNKNOWN("ReportErrorOS")
00459 }

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

Definition at line 590 of file ErrorHandler.cpp.

00594 {
00595     if (!m_pLog)
00596         return;
00597 
00598     try
00599     {
00600         //Convert the number
00601         char aTmp[11];
00602         ltoa(dwAdditionalData,aTmp,10);
00603 
00604         //Create the new message
00605         std::string sNewMessage(rMessage);
00606         sNewMessage+=", Additional data: ";
00607         sNewMessage+=aTmp;
00608 
00609         //Report to the log
00610         WriteStaticError(rClass,
00611                          rMethod,
00612                          sNewMessage);
00613     }
00614     ERROR_UNKNOWN("ReportStaticError")
00615 }

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

Definition at line 573 of file ErrorHandler.cpp.

00576 {
00577     if (!m_pLog)
00578         return;
00579 
00580     try
00581     {
00582         //Report to the log
00583         WriteStaticError(rClass,
00584                          rMethod,
00585                          rMessage);
00586     }
00587     ERROR_UNKNOWN("ReportStaticError")
00588 }

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

Definition at line 553 of file ErrorHandler.cpp.

00555 {
00556     if (!m_pLog)
00557         return;
00558 
00559     try
00560     {
00561         //Get the last error
00562         DWORD dwLastError;
00563         dwLastError=GetLastError();
00564 
00565         //Report the error
00566         WriteStaticError(rClass,
00567                           rMethod,
00568                           ErrorCodeToString(dwLastError));
00569     }
00570     ERROR_UNKNOWN("ReportStaticError")
00571 }

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

Definition at line 392 of file ErrorHandler.cpp.

00395 {
00396     if (!m_pLog)
00397         return;
00398 
00399     try
00400     {
00401         //Get the last error
00402         DWORD dwLastError;
00403         dwLastError=GetLastError();
00404 
00405         //Format the message
00406         std::string sMessage;
00407         sMessage=rMessage;
00408         sMessage+=", with error code: ";
00409 
00410         //Convert the error code
00411         char aTmp[11];
00412         itoa(dwLastError,aTmp,10);
00413 
00414         //Add it again
00415         sMessage+=aTmp;
00416         sMessage+=" ";
00417         sMessage+=ErrorCodeToString(dwLastError);
00418         
00419         //Report to the log
00420         WriteStaticError(rClass,
00421                          rMethod,
00422                          sMessage);
00423     }
00424     ERROR_UNKNOWN("ReportStaticError")
00425 }

void CThreadPool::SetExtraDataDrop ( BOOL bDrop )

Definition at line 822 of file ThreadPool.cpp.

00823 {
00824     m_bDrop=bDrop;
00825 }

void CErrorHandler::SetLocalLog	(	CErrorLog *	pLog,
		bool	bWriteToMain = `false`
	)			`[inherited]`

Definition at line 543 of file ErrorHandler.cpp.

00545 {
00546     //Save the log
00547     m_pLocalLog=pLog;
00548 
00549     //Save the write to main flag
00550     m_bWriteToMain=bWriteToMain;
00551 }

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

Definition at line 509 of file ErrorHandler.cpp.

00510 {
00511     //Save the new log
00512     m_pLog=pLog;
00513 }

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

Definition at line 139 of file ErrorHandler.cpp.

00140 {
00141     //Save the class name
00142     m_sClassName=rName;
00143 }

void CThreadPool::SetPoolName ( const std::string & rName )

Definition at line 855 of file ThreadPool.cpp.

00856 {
00857     m_sName=rName;
00858 }

void CThreadPool::SetSleepInterval ( DWORD dwSleepInterval )

Definition at line 817 of file ThreadPool.cpp.

00818 {
00819     m_dwSleepInterval=dwSleepInterval;
00820 }

void CThreadPool::SetTimeout ( DWORD dwTimeout )

Definition at line 263 of file ThreadPool.cpp.

00264 {
00265     m_dwTimeout=dwTimeout;
00266 }

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

Definition at line 385 of file ThreadPool.cpp.

00387 {
00388     try
00389     {
00390         return SubmitJob(NULL,
00391                          NULL,
00392                          pJobProc,
00393                          lpData);
00394     }
00395     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00396 }

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

Definition at line 372 of file ThreadPool.cpp.

00374 {
00375     try
00376     {
00377         return SubmitJob(NULL,
00378                          pJobProc,
00379                          NULL,
00380                          lpData);
00381     }
00382     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00383 }

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

Definition at line 359 of file ThreadPool.cpp.

00361 {
00362     try
00363     {
00364         return SubmitJob(pJobProc,
00365                          NULL,
00366                          NULL,
00367                          lpData);
00368     }
00369     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00370 }

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

Definition at line 168 of file ErrorHandler.cpp.

00171 {
00172     //Do we have a log?
00173     if (!GetLog())
00174         return;
00175 
00176     //Format the msg
00177     std::string sError;
00178     sError=FormatData(rClass,
00179                       rMethod,
00180                       rError);
00181 
00182     //Write it
00183     GetLog()->WriteError(sError);
00184 
00185     //Write to main
00186     if (m_bWriteToMain &&
00187         m_pLog)
00188         //Write it
00189         m_pLog->WriteError(sError);
00190 }

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

Definition at line 360 of file ErrorHandler.cpp.

00362 {
00363     if (!GetLog())
00364         return;
00365 
00366     try
00367     {
00368         //Report to the log
00369         WriteMessage(m_sClassName,
00370                      rMethod,
00371                      rMessage);
00372     }
00373     ERROR_UNKNOWN("WriteMessage")
00374 }

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

Definition at line 226 of file ErrorHandler.cpp.

00229 {
00230     //Do we have a log?
00231     if (!GetLog())
00232         return;
00233 
00234     //Format the msg
00235     std::string sMsg;
00236     sMsg=FormatData(rClass,
00237                     rMethod,
00238                     rMessage,
00239                     false);
00240 
00241     //Write it
00242     GetLog()->WriteMessage(sMsg);
00243 
00244     //Write to main
00245     if (m_bWriteToMain &&
00246         m_pLog)
00247         //Write it
00248         m_pLog->WriteMessage(sMsg);
00249 }

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

Definition at line 192 of file ErrorHandler.cpp.

00195 {
00196     //Do we have a log?
00197     if (!m_pLog)
00198         return;
00199 
00200     //Format the msg
00201     std::string sError;
00202     sError=FormatData(rClass,
00203                       rMethod,
00204                       rError);
00205 
00206     //Write it
00207     m_pLog->WriteError(sError);
00208 }

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

Definition at line 210 of file ErrorHandler.cpp.

00213 {
00214     //Do we have a log?
00215     if (!m_pLog)
00216         return;
00217 
00218     //Format the msg
00219     std::string sMsg;
00220     sMsg=FormatData(rClass,
00221                     rMethod,
00222                     rMessage,
00223                     false);
00224 }

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

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation