CPeriodicThread Class Reference

#include <PeriodicThread.h>

Inheritance diagram for CPeriodicThread:

[legend]

Collaboration diagram for CPeriodicThread:

[legend]

List of all members.

Public Types
enum	_ThreadStage { tsStart, tsBody, tsEnd }
typedef enum CPeriodicThread::_ThreadStage	ThreadStage
typedef PeriodicThreadProc	LPPeriodicThreadProc
typedef BOOL(*	PeriodicThreadProc )(ThreadStage aStage, LPVOID pParam)
Public Member Functions
void	SetPriority (CGenericThread::ThreadPriority aPriority)
CGenericThread *	GetThread () const
void	SetThreadTimeout (DWORD dwTimeout)
BOOL	Start (DWORD dwInterval, LPVOID lpData)
BOOL	Stop ()
	CPeriodicThread (PeriodicThreadProc pProc)
virtual	~CPeriodicThread ()
void	SetLocalLog (CErrorLog *pLog)
Static Public Member Functions
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	SetLog (CErrorLog *pLog)
Protected Member Functions
const std::string &	GetClassName () const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
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, 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	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
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)

---

Detailed Description

Definition at line 50 of file PeriodicThread.h.

---

Member Typedef Documentation

typedef enum CErrorHandler::_LogPriority CErrorHandler::LogPriority [inherited]

typedef PeriodicThreadProc CPeriodicThread::LPPeriodicThreadProc

Definition at line 65 of file PeriodicThread.h.

typedef BOOL(* CPeriodicThread::PeriodicThreadProc)(ThreadStage aStage, LPVOID pParam)

typedef enum CPeriodicThread::_ThreadStage CPeriodicThread::ThreadStage

---

Member Enumeration Documentation

enum CErrorHandler::_LogPriority [inherited]

Enumerator:

lpDebug
lpMessage
lpCritical
lpError

Definition at line 53 of file ErrorHandler.h.

    {
        lpDebug,
        lpMessage,
        lpCritical,
        lpError
    } LogPriority;

enum CPeriodicThread::_ThreadStage

Enumerator:

tsStart
tsBody
tsEnd

Definition at line 54 of file PeriodicThread.h.

    {
        tsStart,
        tsBody,
        tsEnd
    } ThreadStage;

---

Constructor & Destructor Documentation

CPeriodicThread::CPeriodicThread

(

PeriodicThreadProc

pProc

)

Definition at line 53 of file PeriodicThread.cpp.

                                                         : CErrorHandler(),
                                                             m_pThread(NULL),
                                                             m_pUserProc(pProc),
                                                             m_pEnterEvent(NULL),
                                                             m_pExitEvent(NULL),
                                                             m_dwInterval(0),
                                                             m_dwThreadTimeout(20000),
                                                             m_bDestructor(FALSE),
                                                             m_bAbort(FALSE)
{
    try
    {
        //Set our name
        SetName(CPeriodicThread_Class);

        //Allocate the thread
        m_pThread=COSManager::CreateThread(PeriodicThread);
    }
    ERROR_HANDLER("CPeriodicThread")
}

CPeriodicThread::~CPeriodicThread

(

)

[virtual]

Definition at line 74 of file PeriodicThread.cpp.

{
    try
    {
        //Indicate tremination
        m_bDestructor=TRUE;

        //Delete our thread
        Stop();
    }
    ERROR_HANDLER("~CPeriodicThread")
}

---

Member Function Documentation

std::string CErrorHandler::ErrorCodeToString

(

DWORD

dwErrorCode

)

[static, inherited]

Definition at line 122 of file ErrorHandler.cpp.

{
    try
    {
        //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;
        sMessage+=(char*)lpMsgBuf;
        
        //Release the buffer
        LocalFree(lpMsgBuf);

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

const std::string & CErrorHandler::GetClassName

(

)

const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 516 of file ErrorHandler.cpp.

{
    return m_sClassName;
}

std::string CErrorHandler::GetCurrentDateTime

(

)

[static, inherited]

Definition at line 521 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","")
}

CGenericThread * CPeriodicThread::GetThread

(

)

const

Definition at line 358 of file PeriodicThread.cpp.

{
    return m_pThread;
}

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

Definition at line 154 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //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
        pLog->ReportError(m_sClassName,
                          rMethod,
                          sError);
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 187 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //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
        pLog->ReportError(m_sClassName,
                          rMethod,
                          sError);
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 275 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //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
        pLog->ReportError(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 218 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        CErrorLog* pLog;
        pLog=GetLog();

        //Report to the log
        pLog->ReportError(m_sClassName,
                          rMethod,
                          rMessage);
    }
    ERROR_UNKNOWN("ReportError")
}

void CErrorHandler::ReportError

(

const std::string &

rMethod

)

const [protected, virtual, inherited]

Definition at line 311 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

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

        //Report the error
        GetLog()->ReportError(m_sClassName,
                              rMethod,
                              ErrorCodeToString(dwLastError));

#else
        GetLog()->ReportCatchError(m_sClassName,
                                   rMethod,
                                   "Unknown error!");
#endif
    }
    ERROR_UNKNOWN("ReportError")
}

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

Definition at line 237 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);
        
        //Get the log
        CErrorLog* pLog;
        pLog=GetLog();

        //Report to the log
        pLog->ReportError(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 489 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
        m_pLog->ReportError(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 472 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Report to the log
        m_pLog->ReportError(rClass,
                            rMethod,
                            rMessage);
    }
    ERROR_UNKNOWN("ReportStaticError")
}

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

Definition at line 446 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

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

        //Report the error
        m_pLog->ReportError(rClass,
                            rMethod,
                            ErrorCodeToString(dwLastError));
#else
        m_pLog->ReportError(rClass,
                            rMethod,
                            "Unknown error!");
#endif
    }
    ERROR_UNKNOWN("ReportStaticError")
}

void CErrorHandler::SetLocalLog

(

CErrorLog *

pLog

)

[inherited]

Definition at line 441 of file ErrorHandler.cpp.

{
    m_pLocalLog=pLog;
}

void CErrorHandler::SetLog

(

CErrorLog *

pLog

)

[static, inherited]

Definition at line 305 of file ErrorHandler.cpp.

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

void CErrorHandler::SetName

(

const std::string &

rName

)

const [protected, inherited]

Definition at line 116 of file ErrorHandler.cpp.

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

void CPeriodicThread::SetPriority

(

CGenericThread::ThreadPriority

aPriority

)

Definition at line 363 of file PeriodicThread.cpp.

{
    try
    {
        //Set the priority
        m_pThread->SetPriority(aPriority);
    }
    ERROR_HANDLER("SetPriority")
}

void CPeriodicThread::SetThreadTimeout

(

DWORD

dwTimeout

)

Definition at line 348 of file PeriodicThread.cpp.

{
    try
    {
        //Save it
        m_dwThreadTimeout=dwTimeout;
    }
    ERROR_HANDLER("SetThreadTimeout")
}

BOOL CPeriodicThread::Start	(	DWORD	dwInterval,
		LPVOID	lpData
	)

Definition at line 199 of file PeriodicThread.cpp.

{
    try
    {
        //Is the interval legal
        if (!dwInterval)
        {
            //Report it
            ReportError("Start","Invalid interval!");

            //Exit
            return FALSE;
        }

        //Are we running 
        if (m_dwInterval ||
            m_pEnterEvent ||
            m_pExitEvent)
        {
            //Report it
            ReportError("Start","Already running!");

            //Exit
            return FALSE;
        }

        //We are not aborting
        m_bAbort=FALSE;

        //Create all
        m_pEnterEvent=COSManager::CreateEvent();
        m_pExitEvent=COSManager::CreateEvent();

        //Save the user data
        m_lpData=lpData;

        //Save the interval
        m_dwInterval=dwInterval;

        //Set it to auto delete
        m_pThread->SetAutoDelete(TRUE);

        //Run the thread
        m_pThread->Start((LPVOID)this);

        //Wait for the event
        if (m_pEnterEvent->Wait(m_dwThreadTimeout) ||
            m_bAbort)
        {
            //Report it
            if (m_bAbort)
                ReportError("Start","User aborted!");
            else
                ReportError("Start","Timeout waiting for thread!");

            //Delete it all
            delete m_pThread;
            m_pThread=COSManager::CreateThread(PeriodicThread);

            //The events
            delete m_pEnterEvent;
            m_pEnterEvent=NULL;

            delete m_pExitEvent;
            m_pExitEvent=NULL;

            //Exit
            return FALSE;
        }
        else
            return TRUE;
    }
    ERROR_HANDLER_RETURN("Start",FALSE)
}

BOOL CPeriodicThread::Stop

(

)

Definition at line 275 of file PeriodicThread.cpp.

{
    try
    {
        if (m_bDestructor)
            if (!m_pEnterEvent ||
                !m_pExitEvent)
            {
                //Just delete the thread
                delete m_pThread;

                //Exit
                return TRUE;
            }
            else
                ;
        else
            //Are we running 
            if (!m_pEnterEvent ||
                !m_pExitEvent)
            {
                //Report it
                ReportError("Stop","Not running!");

                //Exit
                return FALSE;
            }

        //Are we aborted
        if (!m_bAbort)
        {
            //The thread ID
            DWORD dwThreadID;
            dwThreadID=m_pThread->GetThreadID();

            //Call the thread
            m_pExitEvent->Set();

            //Wait for the thread
            if (GetCurrentThreadId()!=dwThreadID &&
                m_pEnterEvent->Wait(m_dwThreadTimeout))
            {
                //Report it
                ReportError("Stop","Timeout waiting for thread!");

                //Delete it by force
                delete m_pThread;
            }
        }

        //Delete it all
        m_pThread=NULL;

        //Do we need to recreate
        if (!m_bDestructor)
            m_pThread=COSManager::CreateThread(PeriodicThread);

        //The events
        delete m_pEnterEvent;
        m_pEnterEvent=NULL;

        delete m_pExitEvent;
        m_pExitEvent=NULL;

        //Set the interval
        m_dwInterval=0;

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

void CErrorHandler::WriteMessage	(	const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData,
		LogPriority	aPriority = lpMessage
	)			[protected, inherited]

Definition at line 355 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;

        //Delegate the call
        GetLog()->WriteMessage(m_sClassName,
                               rMethod,
                               sNewMessage,
                               aPriority);
    }
    ERROR_UNKNOWN("WriteMessage")
}

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

Definition at line 337 of file ErrorHandler.cpp.

{
    if (!GetLog())
        return;

    try
    {
        //Delegate the call
        GetLog()->WriteMessage(m_sClassName,
                               rMethod,
                               rMessage,
                               aPriority);
    }
    ERROR_UNKNOWN("WriteMessage")
}

void CErrorHandler::WriteStaticMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData,
		LogPriority	aPriority = lpMessage
	)			[static, protected, inherited]

Definition at line 403 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;

        //Delegate the call
        m_pLog->WriteMessage(rClass,
                             rMethod,
                             sNewMessage,
                             aPriority);
    }
    ERROR_UNKNOWN("WriteStaticMessage")
}

void CErrorHandler::WriteStaticMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		LogPriority	aPriority = lpMessage
	)			[static, protected, inherited]

Definition at line 383 of file ErrorHandler.cpp.

{
    if (!m_pLog)
        return;

    try
    {
        //Delegate the call
        m_pLog->WriteMessage(rClass,
                             rMethod,
                             rMessage,
                             aPriority);
    }
    ERROR_UNKNOWN("WriteStaticMessage")
}

---

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

• PeriodicThread.h
• PeriodicThread.cpp