CSocketThreadManagerImp Class Reference

#include <SocketThreadManagerImp.h>

Inheritance diagram for CSocketThreadManagerImp:

[legend]

Collaboration diagram for CSocketThreadManagerImp:

[legend]

List of all members.

Classes
struct	_ExtensionData
Public Types
typedef TimeoutProc	LPTimeoutProc
typedef struct CSocketThreadManager::_TimerID	TimerID
typedef void(*	TimeoutProc )(LPVOID pParam)
Public Member Functions
HWND	GetWindowHandle (CAsyncSocket *pSocket)
void	RemoveSocket (CAsyncSocket *pSocket)
BOOL	Initialize (unsigned long ulThreadCount)
	CSocketThreadManagerImp (HINSTANCE hInstance)
virtual	~CSocketThreadManagerImp ()
void	SetCleanTimeout (DWORD dwTimeout)
BOOL	IsInitialized () const
unsigned long	GetNumberOfThreads () const
const std::string &	GetClassName () const
BOOL	ReSetTimeout (const TimerID &rTimerID)
BOOL	RemoveTimeout (TimerID &aTimerID, BOOL bInvokeDeleteProc=FALSE)
TimerID	RegisterTimeout (int iMS, LPTimeoutProc pProc, LPVOID pData, BOOL bClearTimeout=FALSE, HWND hHandle=NULL, TimerID *pTimer=NULL, LPTimeoutProc pDeleteProc=NULL)
void	DecreaseSocketCount (HWND hWindowHandle, BOOL bFreeze=FALSE)
void	DecreaseTimeoutCount (HWND hWindowHandle, BOOL bFreeze=FALSE)
HWND	GetWindowHandle (BOOL bTimeout=FALSE)
const CGenericThread *	GetThreadByHWND (HWND hWindowHandle) const
BOOL	Initialize (unsigned long ulThreadCount, LPCSTR lpClassName)
BOOL	Uninitialize ()
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 Types
typedef struct CSocketThreadManager::_ThreadDataExtend	ThreadDataExtend
typedef struct CSocketThreadManager::_TimeoutData	TimeoutData
typedef std::map< unsigned int, TimeoutData >	TOMap
typedef struct CSocketThreadManager::_ThreadData	ThreadData
Protected Member Functions
virtual void	ParseDispatchMessage (const MSG &rMsg, ThreadData *pData)
virtual void	CreateExtendedData (ThreadDataExtend &rData)
virtual void	DeleteExtendedData (ThreadDataExtend &rData)
ThreadData *	GetDataByHWND (HWND hHandle) 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 51 of file SocketThreadManagerImp.h.

---

Member Typedef Documentation

typedef TimeoutProc CSocketThreadManager::LPTimeoutProc [inherited]

Definition at line 66 of file SocketThreadManager.h.

typedef struct CSocketThreadManager::_ThreadData CSocketThreadManager::ThreadData [protected, inherited]

typedef struct CSocketThreadManager::_ThreadDataExtend CSocketThreadManager::ThreadDataExtend [protected, inherited]

typedef struct CSocketThreadManager::_TimeoutData CSocketThreadManager::TimeoutData [protected, inherited]

typedef void(* CSocketThreadManager::TimeoutProc)(LPVOID pParam) [inherited]

typedef struct CSocketThreadManager::_TimerID CSocketThreadManager::TimerID [inherited]

typedef std::map<unsigned int,TimeoutData> CSocketThreadManager::TOMap [protected, inherited]

Definition at line 168 of file SocketThreadManager.h.

---

Constructor & Destructor Documentation

CSocketThreadManagerImp::CSocketThreadManagerImp

(

HINSTANCE

hInstance

)

Definition at line 78 of file SocketThreadManagerImp.cpp.

                                                                    : CSocketThreadManager(hInstance),
                                                                        m_hLocalInstance(hInstance),
                                                                        m_bStatic(FALSE)
{
    try
    {
        //Set our name
        SetName(CSocketThreadManagerImp_Class);
    }
    ERROR_HANDLER("CSocketThreadManagerImp")
}

CSocketThreadManagerImp::~CSocketThreadManagerImp

(

)

[virtual]

Definition at line 90 of file SocketThreadManagerImp.cpp.

{
    try
    {
        //Are we static version?
        if (m_bStatic)
            //Remove the window
            if (m_bWindow)
            {
                //Unregister it
                ::UnregisterClass(CSocketThreadManagerImp_Class,
                                  m_hInstance);

                //No window
                m_bWindow=FALSE;
            }
            else
                ;
        else
            //Uninitialize 
            Uninitialize();
    }
    ERROR_HANDLER("~CSocketThreadManagerImp")
}

---

Member Function Documentation

void CErrorHandler::ClearStaticLogs

(

)

[static, inherited]

Definition at line 680 of file ErrorHandler.cpp.

{
    //Delete the logs
    delete m_pSecondLevelLog;
    m_pSecondLevelLog=NULL;

    delete m_pThirdLevelLog;
    m_pThirdLevelLog=NULL;
}

void CSocketThreadManagerImp::CreateExtendedData

(

ThreadDataExtend &

rData

)

[protected, virtual]

Reimplemented from CSocketThreadManager.

Definition at line 149 of file SocketThreadManagerImp.cpp.

{
    try
    {
        //Create the struct
        ExtensionData* pData;
        pData=new ExtensionData;

        //Populate it
        pData->pCSection=COSManager::CreateCriticalSection();
        
        //Put it in the data
        rData.lpData=(LPVOID)pData;
    }
    ERROR_HANDLER("CreateExtendedData")
}

void CSocketThreadManager::DecreaseSocketCount	(	HWND	hWindowHandle,
		BOOL	bFreeze = FALSE
	)			[inherited]

Definition at line 550 of file SocketThreadManager.cpp.

{
    try
    {
        //First find the window handle
        int iIndex;
        iIndex=GetIndexByHWND(hWindowHandle);

        //Check it's valid
        if (!iIndex)
            return;

        //Enter the critical section
        CCriticalAutoRelease aRelease(m_pCSection);

        //Decrement the socket count
        if (m_pThreadData[iIndex-1].iSocketCount>0)
        {
            --m_pThreadData[iIndex-1].iSocketCount;
            m_pThreadData[iIndex-1].bFreeze=bFreeze;
        }
    }
    ERROR_HANDLER("DecreaseSocketCount")
}

void CSocketThreadManager::DecreaseTimeoutCount	(	HWND	hWindowHandle,
		BOOL	bFreeze = FALSE
	)			[inherited]

Definition at line 576 of file SocketThreadManager.cpp.

{
    try
    {
        //First find the window handle
        int iIndex;
        iIndex=GetIndexByHWND(hWindowHandle);

        //Check it's valid
        if (!iIndex)
            return;

        //Enter the critical section
        CCriticalAutoRelease aRelease(m_pCSection);

        //Decrement the socket count
        if (m_pThreadData[iIndex-1].iTimeoutCount>0)
        {
            --m_pThreadData[iIndex-1].iTimeoutCount;
            m_pThreadData[iIndex-1].bFreeze=bFreeze;
        }
    }
    ERROR_HANDLER("DecreaseTimeoutCount")
}

void CSocketThreadManagerImp::DeleteExtendedData

(

ThreadDataExtend &

rData

)

[protected, virtual]

Reimplemented from CSocketThreadManager.

Definition at line 166 of file SocketThreadManagerImp.cpp.

{
    try
    {
        //Take the data
        ExtensionData* pData;
        pData=(ExtensionData*)rData.lpData;

        //Is it legal?
        if (pData)
        {
            //Our delete vector
            typedef std::vector<CAsyncSocket*> DeleteVector;

            //Our vector
            DeleteVector aDeleteVector;

            {
                //Lock the CS
                CCriticalAutoRelease aRelease(pData->pCSection);

                //Iterate to delete all the data
                SocketMap::iterator aIterator;
                aIterator=pData->aSocketsMap.begin();
                while (aIterator!=pData->aSocketsMap.end())
                {
                    //Add the socket
                    aDeleteVector.push_back(aIterator->second);

                    //Delete it
                    aIterator=pData->aSocketsMap.erase(aIterator);
                }
            }

            //Delete the sockets
            for (int iCount=0;
                 iCount<aDeleteVector.size();
                 ++iCount)
                try
                {
                    //Set to delete
                    aDeleteVector[iCount]->SetDeleting();

                    //Delete the socket
                    delete aDeleteVector[iCount];
                }
                ERROR_HANDLER("DeleteExtendedData - Socket delete")

            //Delete the CS
            delete pData->pCSection;

            //Delete it
            delete pData;

            //Remove from data
            rData.lpData=NULL;
        }
    }
    ERROR_HANDLER("DeleteExtendedData")
}

std::string CErrorHandler::ErrorCodeToString

(

DWORD

dwErrorCode

)

[static, inherited]

Definition at line 251 of file ErrorHandler.cpp.

{
    try
    {
        //Try to look it in the errors
        if (!CErrorsRepository::GetInstance().GetErrorsMap().empty())
        {
            //Search
            CErrorsRepository::ErrorMap::const_iterator aIterator;
            aIterator=CErrorsRepository::GetInstance().GetErrorsMap().find(dwErrorCode);

            //Do we have it
            if (aIterator!=CErrorsRepository::GetInstance().GetErrorsMap().end())
                return aIterator->second;
        }

        //Get the error string
        LPVOID lpMsgBuf;
        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                      FORMAT_MESSAGE_FROM_SYSTEM | 
                      FORMAT_MESSAGE_IGNORE_INSERTS,
                      NULL,
                      dwErrorCode,
                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                      (LPTSTR) &lpMsgBuf,
                      0,
                      NULL);

        //Save it
        std::string sMessage;

        //Do we have the message?
        if (lpMsgBuf)
        {
            //Save it
            sMessage=(char*)lpMsgBuf;
            
            //Release the buffer
            LocalFree(lpMsgBuf);
        }
        else
            //Failed to find
            sMessage="No error description found!";

        //Done
        return sMessage;
    }
    catch (...)
    {
        return "Unknown";
    }
}

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.

{
    //Our message
    std::string sMsg;

    //Is it an error?
    if (bError)
        sMsg="*** Error *** ";
    else
        sMsg="###  Msg  ### ";

    //Add the data now
    sMsg+="in "+rClass;
    sMsg+="::"+rMethod;
    sMsg+=" - " + rMsgOrError;

    //Done
    return sMsg;
}

const std::string & CSocketThreadManager::GetClassName

(

)

const [inherited]

Reimplemented from CErrorHandler.

Definition at line 996 of file SocketThreadManager.cpp.

{
    return m_sClassName;
}

std::string CErrorHandler::GetCurrentDateTime

(

)

[static, inherited]

Definition at line 622 of file ErrorHandler.cpp.

{
    try
    {
        //Our string
        std::string sDate;

        //Our tmp buf
        char cTmp[128];

        //Get date
        _strdate(cTmp);
        sDate=cTmp;
        sDate+=' ';

        //Get time
        _strtime(cTmp);
        sDate+=cTmp;

        //Done
        return sDate;
    }
    ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","")
}

CSocketThreadManager::ThreadData * CSocketThreadManager::GetDataByHWND

(

HWND

hHandle

)

const [protected, inherited]

Definition at line 602 of file SocketThreadManager.cpp.

{
    try
    {
        //Get the index
        int iIndex;
        iIndex=GetIndexByHWND(hHandle);

        //Do we have it?
        if (iIndex)
            return &m_pThreadData[iIndex-1];
        else
            return NULL;
    }
    ERROR_HANDLER_RETURN("GetDataByHWND",NULL)
}

unsigned long CSocketThreadManager::GetNumberOfThreads

(

)

const [inherited]

Definition at line 1006 of file SocketThreadManager.cpp.

{
    return m_ulThreadCount;
}

CErrorHandler * CErrorHandler::GetSecondaryLog

(

)

[static, inherited]

Definition at line 658 of file ErrorHandler.cpp.

{
    //Do we have log
    if (!m_pSecondLevelLog)
        //Create it
        m_pSecondLevelLog=new CErrorHandler;

    //Return it
    return m_pSecondLevelLog;
}

CErrorHandler * CErrorHandler::GetThirdLog

(

)

[static, inherited]

Definition at line 669 of file ErrorHandler.cpp.

{
    //Do we have log
    if (!m_pThirdLevelLog)
        //Create it
        m_pThirdLevelLog=new CErrorHandler;

    //Return it
    return m_pThirdLevelLog;
}

const CGenericThread * CSocketThreadManager::GetThreadByHWND

(

HWND

hWindowHandle

)

const [inherited]

Definition at line 529 of file SocketThreadManager.cpp.

{
    try
    {
        //First find the window handle
        int iIndex;
        iIndex=GetIndexByHWND(hWindowHandle);

        //Check it's valid
        if (!iIndex)
            return NULL;

        //Enter the critical section
        CCriticalAutoRelease aRelease(m_pCSection);

        //Return the thread
        return m_pThreadData[iIndex-1].pThread;
    }
    ERROR_HANDLER_RETURN("GetThreadByHWND",NULL)
}

HWND CSocketThreadManager::GetWindowHandle

(

BOOL

bTimeout = FALSE

)

[inherited]

Definition at line 500 of file SocketThreadManager.cpp.

{   
    try
    {
        //Shared resource
        CCriticalAutoRelease aRelease(m_pCSection);
    
        //Get the freeiest index
        int iIndex;
        iIndex=GetMostAvailableThread();

        //Check it's valid
        if (!iIndex)
            //Quit
            return 0;
    
        //Check what to increase
        if (bTimeout)
            ++m_pThreadData[iIndex-1].iTimeoutCount;
        else
            //Increase the socket count
            ++m_pThreadData[iIndex-1].iSocketCount;

        //Done
        return m_pThreadData[iIndex-1].hWindowHandle;
    }
    ERROR_HANDLER_RETURN("GetWindowHandle",0)
}

HWND CSocketThreadManagerImp::GetWindowHandle

(

CAsyncSocket *

pSocket

)

Definition at line 280 of file SocketThreadManagerImp.cpp.

{
    try
    {
        //Allocate a handle
        HWND hHandle;
        hHandle=CSocketThreadManager::GetWindowHandle();

        //Do we have it?
        if (hHandle)
            //Add the socket
            AddSocketToList(pSocket,
                            hHandle);

        //Done
        return hHandle;
    }
    ERROR_HANDLER_RETURN("GetWindowHandle",NULL)
}

BOOL CSocketThreadManager::Initialize	(	unsigned long	ulThreadCount,
		LPCSTR	lpClassName
	)			[inherited]

Definition at line 113 of file SocketThreadManager.cpp.

{
    try
    {
        //Are we initialized?
        if (m_bInitialized)
        {
            //Report it
            ReportError("Initialize","Already initialized!");

            //Exit
            return FALSE;
        }

        //Check the number of threads
        if (ulThreadCount>MAX_THREADS)
        {
            //Report it
            ReportError("Initialize","Too many threads to spawn!");

            //Exit
            return FALSE;
        }

        //Check the number of threads
        if (!ulThreadCount)
        {
            //Report it
            ReportError("Initialize","Can't have zero threads!");

            //Exit
            return FALSE;
        }

        //Save the count
        m_ulThreadCount=ulThreadCount;

        //Try to spawn the threads
        return SpawnThreads(lpClassName);
    }
    ERROR_HANDLER_RETURN("Initialize",FALSE)
}

BOOL CSocketThreadManagerImp::Initialize

(

unsigned long

ulThreadCount

)

Definition at line 227 of file SocketThreadManagerImp.cpp.

{
    try
    {
        //First create the window class
        if (!m_bWindow)
        {
            //Save the instance
            m_hInstance=m_hLocalInstance;

            if (!RegisterWindow(m_hInstance))
            {
                //Report it
                ReportErrorOS("SetHandlers","Error registering the window, please check API error!");

                //Exit
                return FALSE;
            }
            else
                //Window is OK
                m_bWindow=TRUE;
        }

        //Initialize our father
        return CSocketThreadManager::Initialize(ulThreadCount,
                                                CSocketThreadManagerImp_Class);
    }
    ERROR_HANDLER_RETURN("Initialize",FALSE)
}

BOOL CSocketThreadManager::IsInitialized

(

)

const [inherited]

Definition at line 1001 of file SocketThreadManager.cpp.

{
    return m_bInitialized;
}

void CSocketThreadManagerImp::ParseDispatchMessage	(	const MSG &	rMsg,
		ThreadData *	pData
	)			[protected, virtual]

Reimplemented from CSocketThreadManager.

Definition at line 115 of file SocketThreadManagerImp.cpp.

{
    //Get the extension data
    ExtensionData* pExtension;
    pExtension=(ExtensionData*)pData->aExtension.lpData;

    //Our new msg
    MSG aNewMsg(rMsg);

    //Do we have param?
    if (rMsg.wParam &&
        IsSocketMessage(aNewMsg.message))
    {
        //Lock the CS
        CCriticalAutoRelease aRelease(pExtension->pCSection);

        //Try to get the socket
        SocketMap::iterator aIterator;
        aIterator=pExtension->aSocketsMap.find((int)rMsg.wParam);

        //Do we have it?
        if (aIterator!=pExtension->aSocketsMap.end())
            //Modify the message
            aNewMsg.wParam=(WPARAM)aIterator->second;
        else
            aNewMsg.wParam=0;
    }

    //Dispatch it
    CSocketThreadManager::ParseDispatchMessage(aNewMsg,
                                               pData);
}

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

Definition at line 647 of file ErrorHandler.cpp.

{
    try
    {
        //Add the error
        CErrorsRepository::GetInstance().GetErrorsMap().insert(CErrorsRepository::ErrorMap::value_type(dwErrorCode,rDescription));
    }
    ERROR_HANDLER_STATIC(CErrorHandler_Class,"RegisterError")
}

CSocketThreadManager::TimerID CSocketThreadManager::RegisterTimeout	(	int	iMS,
		LPTimeoutProc	pProc,
		LPVOID	pData,
		BOOL	bClearTimeout = FALSE,
		HWND	hHandle = NULL,
		TimerID *	pTimer = NULL,
		LPTimeoutProc	pDeleteProc = NULL
	)			[inherited]

Definition at line 714 of file SocketThreadManager.cpp.

{
    TimerID aTimerID;
    aTimerID.iIndex=0;

    try
    {
        //Do we have a timer ?
        if (pTimer)
            memset(pTimer,0,sizeof(TimerID));

        int iIndex;

        //Create the data structure (to save time on the CS)
        TimeoutData aData;
        aData.pTimeoutProc=pProc;
        aData.pData=pData;
        aData.bClearTimeout=bClearTimeout;
        aData.pTimer=pTimer;
        aData.pDeleteProc=pDeleteProc;

        //Enter the CS
        CCriticalAutoRelease aRelease(m_pCSection);

        //Do we have a handle
        if (hHandle)
        {
            //Get it
            iIndex=GetIndexByHWND(hHandle);

            //Do we have it
            if (!iIndex)
            {
                //Report it
                ReportError("RegisterTimeout","Failed to find handle!");

                //Exit
                return aTimerID;
            }
            else
                --iIndex;           
        }
        else
        {
            //Get the handler
            iIndex=GetMostAvailableThread();

            //Check it's legal
            if (!iIndex)
            {
                //Report the error
                ReportError("RegisterTimeout","Failed to find thread!");

                //Quit
                return aTimerID;
            }

            //Reset the index
            --iIndex;
        }

        //Our timer ID
        unsigned int iTimerID;
        iTimerID=0;

        //Timer counter
        static int sTimerCounter=1000000;

        //Get the timerID
        int iSetTimerID;
        iSetTimerID=sTimerCounter++;

        //Lock the thread data
        CCriticalAutoRelease aRelease2(m_pThreadData[iIndex].pCSection);

        //Increase the timeout count
        ++m_pThreadData[iIndex].iTimeoutCount;

        //Register the data
        m_pThreadData[iIndex].pMap.insert(TOMap::value_type(iSetTimerID,aData));

        //Exit the CS
        aRelease2.Exit();
        aRelease.Exit();

        //Register the timeout
        iTimerID=SetTimer(m_pThreadData[iIndex].hWindowHandle,
                          iSetTimerID,
                          iMS,
                          NULL);

        //Check we have the timer
        if (!iTimerID)
        {
            {
                //Remove it
                //Lock the thread data
                CCriticalAutoRelease aRelease2(m_pThreadData[iIndex].pCSection);

                //Increase the timeout count
                --m_pThreadData[iIndex].iTimeoutCount;

                //Register the data
                m_pThreadData[iIndex].pMap.erase(iSetTimerID);
            }

            //Write the error
            ReportError("RegisterTimeout","Failed to create the timer!");

            //Quit
            return aTimerID;
        }

        //Create the data
        aTimerID.iTimerID=iSetTimerID;
        aTimerID.iIndex=iIndex+1;
        aTimerID.iMS=iMS;

        //Do we have a timer ?
        if (pTimer)
            memcpy(pTimer,&aTimerID,sizeof(aTimerID));

        //Done
        return aTimerID;
    }
    ERROR_HANDLER_RETURN("RegisterTimeout",aTimerID)
}

void CSocketThreadManagerImp::RemoveSocket

(

CAsyncSocket *

pSocket

)

Definition at line 330 of file SocketThreadManagerImp.cpp.

{
    try
    {
        //Get the handle
        HWND hHandle;
        hHandle=pSocket->GetWindowHandle();

        //Do we have it
        if (!hHandle)
        {
            //Report it
            ReportError("RemoveSocket","Received socket without a handle!");

            //Exit
            return;
        }

        //Find the thread data
        ThreadData* pData;
        pData=GetDataByHWND(hHandle);

        //Do we have it
        if (!pData)
            //Report it
            ReportError("RemoveSocket","Failed to find thread data!");
        else
        {
            //Get our extension
            ExtensionData* pExtension;
            pExtension=(ExtensionData*)pData->aExtension.lpData;

            {
                //Lock the CS
                CCriticalAutoRelease aRelease(pExtension->pCSection);

                //Remove from the map
                pExtension->aSocketsMap.erase(pSocket->GetAsyncHandle());
            }

            //Decrease socket count
            DecreaseSocketCount(hHandle,
                                TRUE);
        }
    }
    ERROR_HANDLER("RemoveSocket")
}

BOOL CSocketThreadManager::RemoveTimeout	(	TimerID &	aTimerID,
		BOOL	bInvokeDeleteProc = FALSE
	)			[inherited]

Definition at line 848 of file SocketThreadManager.cpp.

{
    //Check it's a valid timeout
    if (!aTimerID.iIndex)
    {
        //Write the error
        ReportError("RemoveTimeout","Received invalid TimerID");

        //Quit
        return FALSE;
    }

    try
    {
        //First unregister the timer
        if (!KillTimer(m_pThreadData[aTimerID.iIndex-1].hWindowHandle,
                       aTimerID.iTimerID))
            //Report it
            ReportErrorOS("RemoveTimeout","Failed to delete timer!");

        {
            //Lock the timeout manager
            CCriticalAutoRelease aRelease(m_pThreadData[aTimerID.iIndex-1].pCSection);

            //Do we need to invoke the delete proc?
            if (!bInvokeDeleteProc)
                //No remove from the map
                m_pThreadData[aTimerID.iIndex-1].pMap.erase(aTimerID.iTimerID);
            else
            {
                //We need to look for the data
                TOMap::iterator aIterator;
                aIterator=m_pThreadData[aTimerID.iIndex-1].pMap.find(aTimerID.iTimerID);

                //Do we have it?
                if (aIterator!=m_pThreadData[aTimerID.iIndex-1].pMap.end())
                {
                    //Do we have the delete proc?
                    if (aIterator->second.pDeleteProc)
                        //Invoke it
                        (*aIterator->second.pDeleteProc)(aIterator->second.pData);

                    //Remove the entry
                    m_pThreadData[aTimerID.iIndex-1].pMap.erase(aIterator);
                }
                else
                    //Report it
                    ReportError("RemoveTimeout","Failed to find data!");
            }
                    
            //Decrease the count
            --m_pThreadData[aTimerID.iIndex-1].iTimeoutCount;

            //Set the old timer ID
            aTimerID.iIndex=0;
            aTimerID.iMS=0;
            aTimerID.iTimerID=0;
        }

        //Done 
        return TRUE;
    }
    ERROR_HANDLER_RETURN("RemoveTimeout",FALSE)
}

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.

{
    if (!GetLog())
        return;

    try
    {
        //Convert the error code
        char aTmp[11];
        sprintf(aTmp,"%d",iErrorCode);

        //Get the string for it
        std::string sError;
        sError=rMessage;
        sError+=", and Socket error: ";
        sError+=aTmp;
        sError+=", ";
        sError+=ErrorCodeToString(iErrorCode);

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sError);
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 333 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Convert the error code
        char aTmp[11];
        sprintf(aTmp,"%d",iErrorCode);

        //Get the string for it
        std::string sError;
        sError="Socket error: ";
        sError+=aTmp;
        sError+=", ";
        sError+=ErrorCodeToString(iErrorCode);

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sError);
    }
    ERROR_UNKNOWN("ReportError")
}

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.

{
    if (!GetLog())
        return;

    try
    {
        //Create the new message
        std::string sNewMessage(rMessage);
        sNewMessage+=", Additional data: ";
        sNewMessage+=rAdditionalData;

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sNewMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

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.

{
    if (!GetLog())
        return;

    try
    {
        //Convert the number
        char aTmp[11];
        ltoa(dwAdditionalData,aTmp,10);

        //Create the new message
        std::string sNewMessage(rMessage);
        sNewMessage+=", Additional data: ";
        sNewMessage+=aTmp;

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sNewMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 376 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   rMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError

(

const std::string &

rMethod

)

const [protected, virtual, inherited]

Definition at line 515 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Report the error
        WriteError(m_sClassName,
                   rMethod,
                   ErrorCodeToString(dwLastError));
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 427 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Format the message
        std::string sMessage;
        sMessage=rMessage;
        sMessage+=", with error code: ";

        //Convert the error code
        char aTmp[11];
        itoa(dwLastError,aTmp,10);

        //Add it again
        sMessage+=aTmp;
        sMessage+=" ";
        sMessage+=ErrorCodeToString(dwLastError);

        //Report to the log
        WriteError(m_sClassName,
                   rMethod,
                   sMessage);
    }
    ERROR_UNKNOWN("ReportErrorOS")
}

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.

{
    if (!m_pLog)
        return;

    try
    {
        //Convert the number
        char aTmp[11];
        ltoa(dwAdditionalData,aTmp,10);

        //Create the new message
        std::string sNewMessage(rMessage);
        sNewMessage+=", Additional data: ";
        sNewMessage+=aTmp;

        //Report to the log
        WriteStaticError(rClass,
                         rMethod,
                         sNewMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

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.

{
    if (!m_pLog)
        return;

    try
    {
        //Report to the log
        WriteStaticError(rClass,
                         rMethod,
                         rMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

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

Definition at line 553 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Report the error
        WriteStaticError(rClass,
                          rMethod,
                          ErrorCodeToString(dwLastError));
    }
    ERROR_UNKNOWN("ReportStaticError")
}

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.

{
    if (!m_pLog)
        return;

    try
    {
        //Get the last error
        DWORD dwLastError;
        dwLastError=GetLastError();

        //Format the message
        std::string sMessage;
        sMessage=rMessage;
        sMessage+=", with error code: ";

        //Convert the error code
        char aTmp[11];
        itoa(dwLastError,aTmp,10);

        //Add it again
        sMessage+=aTmp;
        sMessage+=" ";
        sMessage+=ErrorCodeToString(dwLastError);
        
        //Report to the log
        WriteStaticError(rClass,
                         rMethod,
                         sMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

BOOL CSocketThreadManager::ReSetTimeout

(

const TimerID &

rTimerID

)

[inherited]

Definition at line 965 of file SocketThreadManager.cpp.

{
    //Check if anyone is smartass
    if (!rTimerID.iTimerID)
    {
        //Report it
        ReportError("ReSetTimeout","Someone send an empty TimerID!");

        //And exit
        return FALSE;
    }

    try
    {
        //Reset the timer
        int iResult;
        iResult=SetTimer(m_pThreadData[rTimerID.iIndex-1].hWindowHandle,
                         rTimerID.iTimerID,
                         rTimerID.iMS,
                         NULL);

        //Check the result
        if (!iResult)
            ReportError("ReSetTimeout","Failed to reset the timeout!");

        //Done
        return iResult!=0;
    }
    ERROR_HANDLER_RETURN("ReSetTimeout",FALSE)
}

void CSocketThreadManager::SetCleanTimeout

(

DWORD

dwTimeout

)

[inherited]

Definition at line 1026 of file SocketThreadManager.cpp.

{
    m_dwCleanTimeout=dwTimeout;
}

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

Definition at line 543 of file ErrorHandler.cpp.

{
    //Save the log
    m_pLocalLog=pLog;

    //Save the write to main flag
    m_bWriteToMain=bWriteToMain;
}

void CErrorHandler::SetLog

(

CErrorLog *

pLog

)

[static, inherited]

Definition at line 509 of file ErrorHandler.cpp.

{
    //Save the new log
    m_pLog=pLog;
}

void CErrorHandler::SetName

(

const std::string &

rName

)

const [protected, inherited]

Definition at line 139 of file ErrorHandler.cpp.

{
    //Save the class name
    m_sClassName=rName;
}

BOOL CSocketThreadManager::Uninitialize

(

)

[inherited]

Definition at line 157 of file SocketThreadManager.cpp.

{
    try
    {
        //Are we initialized?
        if (!m_bInitialized)
            return TRUE;

        //Are we a static class
        if (m_bStaticClass)
            //Deallocate the class
            UnregisterClass();
        else
            //Delete the thread data
            CleanThreads(FALSE);

        //Unitialized
        m_bInitialized=FALSE;

        //Done
        return TRUE;
    }
    ERROR_HANDLER_RETURN("Uninitialize",FALSE)
}

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.

{
    //Do we have a log?
    if (!GetLog())
        return;

    //Format the msg
    std::string sError;
    sError=FormatData(rClass,
                      rMethod,
                      rError);

    //Write it
    GetLog()->WriteError(sError);

    //Write to main
    if (m_bWriteToMain &&
        m_pLog)
        //Write it
        m_pLog->WriteError(sError);
}

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

Definition at line 360 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Report to the log
        WriteMessage(m_sClassName,
                     rMethod,
                     rMessage);
    }
    ERROR_UNKNOWN("WriteMessage")
}

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.

{
    //Do we have a log?
    if (!GetLog())
        return;

    //Format the msg
    std::string sMsg;
    sMsg=FormatData(rClass,
                    rMethod,
                    rMessage,
                    false);

    //Write it
    GetLog()->WriteMessage(sMsg);

    //Write to main
    if (m_bWriteToMain &&
        m_pLog)
        //Write it
        m_pLog->WriteMessage(sMsg);
}

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.

{
    //Do we have a log?
    if (!m_pLog)
        return;

    //Format the msg
    std::string sError;
    sError=FormatData(rClass,
                      rMethod,
                      rError);

    //Write it
    m_pLog->WriteError(sError);
}

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.

{
    //Do we have a log?
    if (!m_pLog)
        return;

    //Format the msg
    std::string sMsg;
    sMsg=FormatData(rClass,
                    rMethod,
                    rMessage,
                    false);
}

---

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

• SocketThreadManagerImp.h
• SocketThreadManagerImp.cpp