CErrorHandler Class Reference

#include <ErrorHandler.h>

Inheritance diagram for CErrorHandler:

Collaboration diagram for CErrorHandler:


Classes
class	CErrorLog
class	CErrorsRepository
Public Member Functions
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
	CErrorHandler ()
	CErrorHandler (const CErrorHandler &rHandler)
virtual	~CErrorHandler ()
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
const std::string &	GetClassName () const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage) 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 50 of file ErrorHandler.h.

Constructor & Destructor Documentation

CErrorHandler::CErrorHandler ( )

Definition at line 114 of file ErrorHandler.cpp.

00114                              : m_pLocalLog(NULL),
00115                                  m_bWriteToMain(false)
00116 {
00117     try
00118     {
00119         //Set it
00120         SetName(CErrorHandler_Class);
00121     }
00122     ERROR_HANDLER("CErrorHandler")
00123 }

CErrorHandler::CErrorHandler ( const CErrorHandler & rHandler )

Definition at line 125 of file ErrorHandler.cpp.

00125                                                           : m_pLocalLog(NULL)
00126 {
00127     try
00128     {
00129         //Set it
00130         SetName(CErrorHandler_Class);
00131     }
00132     ERROR_HANDLER("CErrorHandler")
00133 }

CErrorHandler::~CErrorHandler ( ) [virtual]

Definition at line 135 of file ErrorHandler.cpp.

00136 {
00137 }

Member Function Documentation

void CErrorHandler::ClearStaticLogs ( ) [static]

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]

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 }

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

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]

Reimplemented in CSocketThreadManager.

Definition at line 617 of file ErrorHandler.cpp.

00618 {
00619     return m_sClassName;
00620 }

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

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 }

CErrorHandler * CErrorHandler::GetSecondaryLog ( ) [static]

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]

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 }

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

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]`

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]`

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]`

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]`

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]`

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]

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]`

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]`

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]`

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]`

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]`

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 CErrorHandler::SetLocalLog	(	CErrorLog *	pLog,
		bool	bWriteToMain = `false`
	)

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]

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]

Definition at line 139 of file ErrorHandler.cpp.

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

void CErrorHandler::WriteError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rError
	)			const

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]`

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

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]`

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]`

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

CErrorHandler Class Reference

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation