CFileLog Class Reference

#include <FileLog.h>

Inheritance diagram for CFileLog:

[legend]

Collaboration diagram for CFileLog:

[legend]

List of all members.

Public Member Functions
void	WriteLog (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, CErrorHandler::LogPriority aPriority)
void	SetMaxLogSize (DWORD dwSize)
BOOL	Initialize (const std::string &rFileName)
	CFileLog ()
virtual	~CFileLog ()
void	SetAutoFlush (BOOL bFlush)
BOOL	GetAutoFlush () const
Protected Member Functions
virtual void	ReportError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
virtual void	WriteMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, CErrorHandler::LogPriority aPriority)

---

Detailed Description

Definition at line 55 of file FileLog.h.

---

Constructor & Destructor Documentation

KOMODIA_NAMESPACE_START CFileLog::CFileLog

(

)

Definition at line 54 of file FileLog.cpp.

                   : CErrorHandler::CErrorLog(),
                       m_pFile(NULL),
                       m_pCSection(NULL),
                       m_dwMaxLogSize(5000000)
{
    //Create the CS
    m_pCSection=COSManager::CreateCriticalSection();
}

CFileLog::~CFileLog

(

)

[virtual]

Definition at line 63 of file FileLog.cpp.

{
    //Close the file
    fclose(m_pFile);

    //Delete the CS
    delete m_pCSection;
}

---

Member Function Documentation

BOOL CErrorHandler::CErrorHandler::CErrorLog::GetAutoFlush

(

)

const [inherited]

Definition at line 80 of file ErrorHandler.cpp.

{
    return m_bAutoFlush;
}

BOOL CFileLog::Initialize

(

const std::string &

rFileName

)

Definition at line 72 of file FileLog.cpp.

{
    //Open's the log file
    try
    {
        //Check if the file is open
        if (m_pFile)
            //close is
            fclose(m_pFile);

        //Which open mode
        BOOL bTruncate;
        bTruncate=FALSE;

        //Do we need to get the file size
        if (m_dwMaxLogSize)
        {
            //Open the file
            HANDLE hFile; 
            hFile=CreateFile(rFileName.c_str(),
                             GENERIC_READ,
                             FILE_SHARE_READ,
                             NULL,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL,
                             NULL);
 
            //Do we have it?
            if (hFile!=INVALID_HANDLE_VALUE) 
            { 
                //Get the file size
                DWORD dwSize;
                dwSize=GetFileSize(hFile,
                                   NULL);

                //Close the file
                CloseHandle(hFile);

                //Is it bigger
                if (dwSize>m_dwMaxLogSize)
                    bTruncate=FALSE;    
            }
        }

        //Now open the file
        if (!bTruncate)
            m_pFile=fopen(rFileName.c_str(),"at");
        else
            m_pFile=fopen(rFileName.c_str(),"wt");

        //Did we manage to open it?
        if (!m_pFile)
            return FALSE;
        else
            return TRUE;
    }
    ERROR_UNKNOWN_RETURN("ReportError",FALSE)
}

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

Implements CErrorHandler::CErrorHandler::CErrorLog.

Definition at line 191 of file FileLog.cpp.

{
    //Delegate call
    WriteLog(rClass,
             rMethod,
             rMessage,
             CErrorHandler::lpError);
}

void CErrorHandler::CErrorHandler::CErrorLog::SetAutoFlush

(

BOOL

bFlush

)

[inherited]

Definition at line 75 of file ErrorHandler.cpp.

{
    m_bAutoFlush=bFlush;
}

void CFileLog::SetMaxLogSize

(

DWORD

dwSize

)

Definition at line 214 of file FileLog.cpp.

{
    m_dwMaxLogSize=dwSize;
}

void CFileLog::WriteLog	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		CErrorHandler::LogPriority	aPriority
	)

Definition at line 131 of file FileLog.cpp.

{
    try
    {
#ifdef _DEBUG
        m_aLog.WriteLog(rClass,
                        rMethod,
                        rMessage,
                        aPriority);
#endif
        //Our error string
        std::string sPrefix;

        //Our string to print
        switch (aPriority)
        {
        case CErrorHandler::lpMessage:
            sPrefix="***MESSAGE*** ";
            break;
        case CErrorHandler::lpCritical:
            sPrefix="***CRITICAL*** ";
            break;
        case CErrorHandler::lpError:
            sPrefix="***ERROR*** ";
            break;
        }

        //Lock it
        CCriticalAutoRelease aRelease(m_pCSection);

        //Do we have a prefix
        if (!sPrefix.empty())
            fprintf(m_pFile,"%s",sPrefix.c_str());

        //First write time
        char tmpbuf[128];

        //Get data
        _strdate(tmpbuf);
        fprintf(m_pFile,"%s ",tmpbuf);

        _strtime(tmpbuf);
        fprintf(m_pFile,"%s: ",tmpbuf);
    
        //Write to log
        fprintf(m_pFile,"%s, %s, %s\n",rClass.c_str(),
                                       rMethod.c_str(),
                                       rMessage.c_str());

        //If error, or auto flush - then flush the data
        if (aPriority==CErrorHandler::lpError ||
            GetAutoFlush())
            fflush(m_pFile);
    }
    ERROR_UNKNOWN("WriteLog")
}

void CFileLog::WriteMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		CErrorHandler::LogPriority	aPriority
	)			[protected, virtual]

Implements CErrorHandler::CErrorHandler::CErrorLog.

Definition at line 202 of file FileLog.cpp.

{
    //Delegate call
    WriteLog(rClass,
             rMethod,
             rMessage,
             aPriority);
}

---

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

• FileLog.h
• FileLog.cpp