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)
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
CTCPSocketAsync *	GetSocket () 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 }

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 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 }

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

Definition at line 68 of file TCPSocketAsyncDelegator.cpp.

00069 {
00070     return m_pSocket;
00071 }

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 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 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 ) [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 }

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

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