CTCPSocketAsyncDelegator Class Reference

#include <TCPSocketAsyncDelegator.h>

Inheritance diagram for CTCPSocketAsyncDelegator:

Collaboration diagram for CTCPSocketAsyncDelegator:


Public Member Functions
BOOL	SocketConnected (int iErrorCode, BOOL bNoEvent=FALSE)
BOOL	LocalSocketReceive (int iErrorCode, BOOL bNoEvent=FALSE)
BOOL	LocalSocketConnect (int iErrorCode, BOOL bNoEvent)
BOOL	LocalSocketClose (int iErrorCode, BOOL bNoEvent)
BOOL	LocalSocketAccept (int iErrorCode, BOOL bNoEvent)
BOOL	OnSocketConnect (int iErrorCode)
BOOL	LocalConnect (unsigned short usSourcePort, IP aDestinationAddress, unsigned short usDestinationPort, BOOL bDisableAsync, BOOL bForceErrorEvent)
BOOL	LocalBind (IP aSourceAddress, unsigned short usPort)
IP	LocalGetBindAddress () const
unsigned short	LocalGetBindPort () const
BOOL	LocalListen (unsigned long ulBackLog)
BOOL	LocalAccept (CTCPSocket *pNewSocket)
void	SetAcceptance (CTCPSocket *pNewSocket, SOCKET aSocket, sockaddr_in aAddress) const
void	SystemTimeout ()
void	SetConnectedTo (const sockaddr_in &rAddress)
void	SwitchEventsType ()
BOOL	SetAsync ()
BOOL	ClearEvents ()
SOCKET	Detach ()
	CTCPSocketAsyncDelegator (CTCPSocketAsync *pSocket)
virtual	~CTCPSocketAsyncDelegator ()
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
CTCPSocketAsync *	GetSocket () const
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 52 of file TCPSocketAsyncDelegator.h.

Constructor & Destructor Documentation

CTCPSocketAsyncDelegator::CTCPSocketAsyncDelegator ( CTCPSocketAsync * pSocket )

Definition at line 53 of file TCPSocketAsyncDelegator.cpp.

00053                                                                            : CErrorHandler(),
00054                                                                                m_pSocket(pSocket)
00055 {
00056     try
00057     {
00058         //Set our name
00059         SetName(CTCPSocketAsyncDelegator_Class);
00060     }
00061     ERROR_HANDLER("CTCPSocketAsyncDelegator")
00062 }

CTCPSocketAsyncDelegator::~CTCPSocketAsyncDelegator ( ) [virtual]

Definition at line 64 of file TCPSocketAsyncDelegator.cpp.

00065 {
00066 }

Member Function Documentation

BOOL CTCPSocketAsyncDelegator::ClearEvents ( )

Definition at line 178 of file TCPSocketAsyncDelegator.cpp.

00179 {
00180     return m_pSocket->ClearEvents();
00181 }

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 }

SOCKET CTCPSocketAsyncDelegator::Detach ( )

Definition at line 183 of file TCPSocketAsyncDelegator.cpp.

00184 {
00185     return m_pSocket->Detach();
00186 }

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 }

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 }

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 }

CTCPSocketAsync * CTCPSocketAsyncDelegator::GetSocket ( ) const [protected]

Definition at line 68 of file TCPSocketAsyncDelegator.cpp.

00069 {
00070     return m_pSocket;
00071 }

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 }

BOOL CTCPSocketAsyncDelegator::LocalAccept ( CTCPSocket * pNewSocket )

Definition at line 164 of file TCPSocketAsyncDelegator.cpp.

00165 {
00166     return m_pSocket->LocalAccept(pNewSocket);
00167 }

BOOL CTCPSocketAsyncDelegator::LocalBind	(	IP	aSourceAddress,
		unsigned short	usPort
	)

Definition at line 112 of file TCPSocketAsyncDelegator.cpp.

00114 {
00115     return m_pSocket->LocalBind(aSourceAddress,
00116                                 usPort);
00117 }

BOOL CTCPSocketAsyncDelegator::LocalConnect	(	unsigned short	usSourcePort,
		IP	aDestinationAddress,
		unsigned short	usDestinationPort,
		BOOL	bDisableAsync,
		BOOL	bForceErrorEvent
	)

Definition at line 99 of file TCPSocketAsyncDelegator.cpp.

00104 {
00105     return m_pSocket->LocalConnect(usSourcePort,
00106                                    aDestinationAddress,
00107                                    usDestinationPort,
00108                                    bDisableAsync,
00109                                    bForceErrorEvent);
00110 }

IP CTCPSocketAsyncDelegator::LocalGetBindAddress ( ) const

Definition at line 147 of file TCPSocketAsyncDelegator.cpp.

00148 {
00149     return m_pSocket->LocalGetBindAddress();
00150 }

unsigned short CTCPSocketAsyncDelegator::LocalGetBindPort ( ) const

Definition at line 152 of file TCPSocketAsyncDelegator.cpp.

00153 {
00154     return m_pSocket->LocalGetBindPort();
00155 }

BOOL CTCPSocketAsyncDelegator::LocalListen ( unsigned long ulBackLog )

Definition at line 188 of file TCPSocketAsyncDelegator.cpp.

00189 {
00190     return m_pSocket->LocalListen(ulBackLog);
00191 }

BOOL CTCPSocketAsyncDelegator::LocalSocketAccept	(	int	iErrorCode,
		BOOL	bNoEvent
	)

Definition at line 157 of file TCPSocketAsyncDelegator.cpp.

00159 {
00160     return m_pSocket->LocalSocketAccept(iErrorCode,
00161                                         bNoEvent);
00162 }

BOOL CTCPSocketAsyncDelegator::LocalSocketClose	(	int	iErrorCode,
		BOOL	bNoEvent
	)

Definition at line 119 of file TCPSocketAsyncDelegator.cpp.

00121 {
00122     return m_pSocket->LocalSocketClose(iErrorCode,
00123                                        bNoEvent);
00124 }

BOOL CTCPSocketAsyncDelegator::LocalSocketConnect	(	int	iErrorCode,
		BOOL	bNoEvent
	)

Definition at line 80 of file TCPSocketAsyncDelegator.cpp.

00082 {
00083     return m_pSocket->LocalSocketConnect(iErrorCode,
00084                                          bNoEvent);
00085 }

BOOL CTCPSocketAsyncDelegator::LocalSocketReceive	(	int	iErrorCode,
		BOOL	bNoEvent = `FALSE`
	)

Definition at line 92 of file TCPSocketAsyncDelegator.cpp.

00094 {
00095     return m_pSocket->LocalSocketReceive(iErrorCode,
00096                                          bNoEvent);
00097 }

BOOL CTCPSocketAsyncDelegator::OnSocketConnect ( int iErrorCode )

Definition at line 87 of file TCPSocketAsyncDelegator.cpp.

00088 {
00089     return m_pSocket->OnSocketConnect(iErrorCode);
00090 }

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 CTCPSocketAsyncDelegator::SetAcceptance	(	CTCPSocket *	pNewSocket,
		SOCKET	aSocket,
		sockaddr_in	aAddress
	)			const

Definition at line 169 of file TCPSocketAsyncDelegator.cpp.

00172 {
00173     m_pSocket->SetAcceptance(pNewSocket,
00174                              aSocket,
00175                              aAddress);
00176 }

BOOL CTCPSocketAsyncDelegator::SetAsync ( )

Definition at line 138 of file TCPSocketAsyncDelegator.cpp.

00139 {
00140     //First clear the events
00141     m_pSocket->ClearEvents();
00142 
00143     //Reset it
00144     return m_pSocket->SetAsync();
00145 }

void CTCPSocketAsyncDelegator::SetConnectedTo ( const sockaddr_in & rAddress )

Definition at line 126 of file TCPSocketAsyncDelegator.cpp.

00127 {
00128     //Delegate the call
00129     m_pSocket->SetConnectedTo(rAddress);
00130 }

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 }

BOOL CTCPSocketAsyncDelegator::SocketConnected	(	int	iErrorCode,
		BOOL	bNoEvent = `FALSE`
	)

Definition at line 73 of file TCPSocketAsyncDelegator.cpp.

00075 {
00076     return m_pSocket->SocketConnected(iErrorCode,
00077                                       bNoEvent);
00078 }

void CTCPSocketAsyncDelegator::SwitchEventsType ( )

Definition at line 132 of file TCPSocketAsyncDelegator.cpp.

00133 {
00134     //Delegate call
00135     m_pSocket->SwitchEventsType();
00136 }

void CTCPSocketAsyncDelegator::SystemTimeout ( )

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

CTCPSocketAsyncDelegator Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation