CWin32Thread Class Reference

#include <Win32Thread.h>

Inheritance diagram for CWin32Thread:

[legend]

Collaboration diagram for CWin32Thread:

[legend]

List of all members.

Public Types
enum	_ThreadStatus { tsSuspended, tsRunning, tsStopped, tsError }
enum	_ThreadPriority {   tpIdle = 0, tpLowest, tpBelowNormal, tpNormal,   tpAboveNormal, tpHighest, tpTimeCritical }
typedef GenericThreadProc	LPGenericThreadProc
typedef enum CGenericThread::_ThreadStatus	ThreadStatus
typedef enum CGenericThread::_ThreadPriority	ThreadPriority
typedef DWORD(*	GenericThreadProc )(LPVOID pParam)
Public Member Functions
virtual BOOL	IsInThread () const
virtual BOOL	SetPriority (CGenericThread::ThreadPriority aPriority)
virtual CGenericThread::ThreadPriority	GetPriority () const
virtual BOOL	Start (LPVOID pData)
virtual BOOL	Stop ()
	CWin32Thread (LPGenericThreadProc pThreadProc)
virtual	~CWin32Thread ()
void	SetBruteTermination (BOOL bBrute)
void	SetAutoDelete (BOOL bAuto)
virtual DWORD	GetThreadID () const
ThreadStatus	GetThreadStatus () const
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
BOOL	GetBruteTermination () const
BOOL	GetAutoDelete () const
LPGenericThreadProc	GetThreadProc () const
void	SetThreadStatus (ThreadStatus aStatus)
virtual LPVOID	GetData () const
void	SetThreadID (DWORD dwThreadID)
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 49 of file Win32Thread.h.

---

Member Typedef Documentation

typedef DWORD(* CGenericThread::GenericThreadProc)(LPVOID pParam) [inherited]

typedef GenericThreadProc CGenericThread::LPGenericThreadProc [inherited]

Definition at line 56 of file GenericThread.h.

typedef enum CGenericThread::_ThreadPriority CGenericThread::ThreadPriority [inherited]

typedef enum CGenericThread::_ThreadStatus CGenericThread::ThreadStatus [inherited]

---

Member Enumeration Documentation

enum CGenericThread::_ThreadPriority [inherited]

Enumerator:

tpIdle
tpLowest
tpBelowNormal
tpNormal
tpAboveNormal
tpHighest
tpTimeCritical

Definition at line 68 of file GenericThread.h.

    {
        tpIdle=0,
        tpLowest,
        tpBelowNormal,
        tpNormal,
        tpAboveNormal,
        tpHighest,
        tpTimeCritical
    } ThreadPriority;

enum CGenericThread::_ThreadStatus [inherited]

Enumerator:

tsSuspended
tsRunning
tsStopped
tsError

Definition at line 59 of file GenericThread.h.

    {
        tsSuspended,
        tsRunning,
        tsStopped,
        tsError
    } ThreadStatus;

---

Constructor & Destructor Documentation

CWin32Thread::CWin32Thread

(

LPGenericThreadProc

pThreadProc

)

Definition at line 51 of file Win32Thread.cpp.

                                                          : CGenericThread(pThreadProc),
                                                              m_hThread(0)
{
    try
    {
        //Set our name
        SetName(CWin32Thread_Class);

        //Create the thread
        if (GetThreadProc())
        {
            //Our thread ID
            DWORD dwThreadID;

            //Create the thread in suspend mode
            m_hThread=CreateThread(NULL,
                                   0,
                                   Win32Thread,
                                   this,
                                   CREATE_SUSPENDED,
                                   &dwThreadID);

            //Check if created
            if (m_hThread)
            {
                //Set the thread ID
                SetThreadID(dwThreadID);

                //Set the status
                SetThreadStatus(tsSuspended);
            }
            else
                //An error
                throw std::string("Failed to create thread!");
        }
        else
            //Throw the error
            throw std::string("No thread proc!");
    }
    ERROR_HANDLER_RETHROW("CWin32Thread")
}

CWin32Thread::~CWin32Thread

(

)

[virtual]

Definition at line 93 of file Win32Thread.cpp.

{
    try
    {
        //Stop the thread
        Stop();
    }
    ERROR_HANDLER("~CWin32Thread")
}

---

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

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

BOOL CGenericThread::GetAutoDelete

(

)

const [protected, inherited]

Definition at line 129 of file GenericThread.cpp.

{
    return m_bAutoDelete;
}

BOOL CGenericThread::GetBruteTermination

(

)

const [protected, inherited]

Definition at line 139 of file GenericThread.cpp.

{
    return m_bBruteTermination;
}

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 617 of file ErrorHandler.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","")
}

LPVOID CGenericThread::GetData

(

)

const [protected, virtual, inherited]

Definition at line 87 of file GenericThread.cpp.

{
    return m_pData;
}

CGenericThread::ThreadPriority CWin32Thread::GetPriority

(

)

const [virtual]

Implements CGenericThread.

Definition at line 310 of file Win32Thread.cpp.

{
    try
    {
        //Check if we have the thread
        if (!m_hThread)
            return CGenericThread::tpNormal;

        int iPriority;

        //Get the priority
        iPriority=GetThreadPriority(m_hThread);

        //And return the value
        switch (iPriority)
        {
        case THREAD_PRIORITY_ABOVE_NORMAL:
            return CGenericThread::tpAboveNormal;
        case THREAD_PRIORITY_BELOW_NORMAL:
            return CGenericThread::tpBelowNormal;
        case THREAD_PRIORITY_HIGHEST:
            return CGenericThread::tpHighest;
        case THREAD_PRIORITY_IDLE:
            return CGenericThread::tpIdle;
        case THREAD_PRIORITY_LOWEST:
            return CGenericThread::tpLowest;
        case THREAD_PRIORITY_NORMAL:
            return CGenericThread::tpNormal;
        case THREAD_PRIORITY_TIME_CRITICAL:
            return CGenericThread::tpTimeCritical;
        default:
            return CGenericThread::tpNormal;
        }
    }
    ERROR_HANDLER_RETURN("GetPriority",CGenericThread::tpNormal)
}

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

DWORD CGenericThread::GetThreadID

(

)

const [virtual, inherited]

Definition at line 77 of file GenericThread.cpp.

{
    return m_dwThreadID;
}

CGenericThread::LPGenericThreadProc CGenericThread::GetThreadProc

(

)

const [protected, inherited]

Definition at line 119 of file GenericThread.cpp.

{
    return m_pThreadProc;
}

CGenericThread::ThreadStatus CGenericThread::GetThreadStatus

(

)

const [inherited]

Definition at line 114 of file GenericThread.cpp.

{
    return m_aThreadStatus;
}

BOOL CWin32Thread::IsInThread

(

)

const [virtual]

Implements CGenericThread.

Definition at line 347 of file Win32Thread.cpp.

{
    return GetCurrentThreadId()==GetThreadID();
}

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

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

void CGenericThread::SetAutoDelete

(

BOOL

bAuto

)

[inherited]

Definition at line 124 of file GenericThread.cpp.

{
    m_bAutoDelete=bAuto;
}

void CGenericThread::SetBruteTermination

(

BOOL

bBrute

)

[inherited]

Definition at line 134 of file GenericThread.cpp.

{
    m_bBruteTermination=bBrute;
}

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 CWin32Thread::SetPriority

(

CGenericThread::ThreadPriority

aPriority

)

[virtual]

Implements CGenericThread.

Definition at line 262 of file Win32Thread.cpp.

{
    try
    {
        static const int iThreadPriority[]={THREAD_PRIORITY_IDLE,
                                            THREAD_PRIORITY_LOWEST,
                                            THREAD_PRIORITY_BELOW_NORMAL,
                                            THREAD_PRIORITY_NORMAL,
                                            THREAD_PRIORITY_ABOVE_NORMAL,
                                            THREAD_PRIORITY_HIGHEST,
                                            THREAD_PRIORITY_TIME_CRITICAL};

        //Do we have a thread
        if (GetThreadStatus()==tsStopped)
        {
            //Recreate the thread
            //Our thread ID
            DWORD dwThreadID;

            //Create the thread in suspend mode
            m_hThread=CreateThread(NULL,
                                   0,
                                   Win32Thread,
                                   this,
                                   CREATE_SUSPENDED,
                                   &dwThreadID);

            //Check if created
            if (m_hThread)
            {
                //Set the thread ID
                SetThreadID(dwThreadID);

                //Set the status
                SetThreadStatus(tsSuspended);
            }
            else
                //Can't run
                return FALSE;
        }

        //Now we can set the priority
        return SetThreadPriority(m_hThread,
                                 iThreadPriority[aPriority]);
    }
    ERROR_HANDLER_RETURN("SetPriority",FALSE)
}

void CGenericThread::SetThreadID

(

DWORD

dwThreadID

)

[protected, inherited]

Definition at line 82 of file GenericThread.cpp.

{
    m_dwThreadID=dwThreadID;
}

void CGenericThread::SetThreadStatus

(

ThreadStatus

aStatus

)

[protected, inherited]

Definition at line 101 of file GenericThread.cpp.

{
    try
    {
        //Enter the CS
        CCriticalAutoRelease aRelease(m_pCSection);

        //Set it
        m_aThreadStatus=aStatus;
    }
    ERROR_HANDLER("SetThreadStatus")
}

BOOL CWin32Thread::Start

(

LPVOID

pData

)

[virtual]

Reimplemented from CGenericThread.

Definition at line 103 of file Win32Thread.cpp.

{
    try
    {
        if (GetThreadStatus()==tsStopped)
        {
            //Recreate the thread
            //Our thread ID
            DWORD dwThreadID;

            //Create the thread in suspend mode
            m_hThread=CreateThread(NULL,
                                   0,
                                   Win32Thread,
                                   this,
                                   CREATE_SUSPENDED,
                                   &dwThreadID);

            //Check if created
            if (m_hThread)
            {
                //Set the thread ID
                SetThreadID(dwThreadID);

                //Set the status
                SetThreadStatus(tsSuspended);
            }
            else
                //Can't run
                return FALSE;
        }
        else if (GetThreadStatus()!=tsSuspended)
            return FALSE;

        //Start the thread
        CGenericThread::Start(pData);

        //Resume the thread
        if (m_hThread)
            if (ResumeThread(m_hThread)!=-1)
                //We are running
                return TRUE;

        return FALSE;
    }
    ERROR_HANDLER_RETURN("Start",FALSE)
}

BOOL CWin32Thread::Stop

(

)

[virtual]

Implements CGenericThread.

Definition at line 151 of file Win32Thread.cpp.

{
    try
    {
        //Only if suspened or running
        //Do we have the thread ?
        if (m_hThread)
        {
            //What status are we
            if (GetThreadStatus()==tsRunning &&
                GetBruteTermination())
                //First try to close it
                if (!TerminateThread(m_hThread,THREAD_DO_NOTHING_EXIT_VALUE))
                {
                    //Close it first
                    CloseHandle(m_hThread);

                    //Reset it
                    m_hThread=NULL;

                    //Exit
                    return FALSE;
                }

            //Are we running, suspended?
            if (GetThreadStatus()==tsSuspended ||
                GetThreadStatus()==tsRunning)
                if (CloseHandle(m_hThread))
                {
                    //Close the handle
                    m_hThread=NULL;

                    //Stopped
                    SetThreadStatus(tsStopped);

                    //Exit
                    return TRUE;
                }
                else
                    return FALSE;
            else
            {
                //Just close the handle
                if (CloseHandle(m_hThread))
                    m_hThread=NULL;

                //Exit
                return FALSE;
            }
        }
        else
            return FALSE;
    }
    ERROR_HANDLER_RETURN("Stop",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:

• Win32Thread.h
• Win32Thread.cpp