E:/Projekte/Open Source/Unwritten/Unwritten C++/projects/Library/source/UnwrittenLogfile.cpp

/*
 *  Unwritten - A distrubuted logging engine
 *  Copyright © 2005 by "The Unwritten Team"
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 **/

#include <UnwrittenLogfile.hpp>
#include <assert.h>
#include <stdarg.h>

UnwrittenLogfile::UnwrittenLogfile( const std::string & szFilename, bool bPrintMessageType )
{
        // set the needed internal variables
        this->m_bDisposed = false;
        this->m_bWaitForNewLine = false;
        this->m_bPrintMessageType = bPrintMessageType;
        this->m_szLogfileName = szFilename;
        this->m_eLoggingType = UnwrittenDebug;

        // try to open the given file
        if( NULL == ( this->m_pFileHandle = fopen( szFilename.c_str(), "w+" ) ) )
                throw new std::exception( std::string( "Cannot create the requested logfile '" + szFilename + "'. Maybe you have no rights to write to the given location!" ).c_str() );
}

UnwrittenLogfile::~UnwrittenLogfile()
{
        // the dispose function should be called before calling
        // the destructor. If this is a debug bild, assert if 
        // if Dispose function was already called
        assert( true == this->m_bDisposed );

        // if the object is not dispoed at this time, call
        // the dispose event by myself ^^
        if( !this->m_bDisposed )
                this->Dispose();
}

void UnwrittenLogfile::Dispose()
{
        // if the logfile is opened, flush the buffer and close the file
        if( this->m_pFileHandle != NULL )
        {
                fflush( this->m_pFileHandle );
                fclose( this->m_pFileHandle );
                this->m_pFileHandle = NULL;
        }

        // this object was disposed
        this->m_bDisposed = true;
}

UnwrittenLogfile::UnwrittenLoggingType UnwrittenLogfile::GetLoggingType()
{
        return( this->m_eLoggingType );
}

void UnwrittenLogfile::SetLoggingType( UnwrittenLoggingType newLoggingType )
{
        this->m_eLoggingType = newLoggingType;
}

void UnwrittenLogfile::PrintMessageType( UnwrittenLoggingType typeOfMessage )
{
        switch( typeOfMessage )
        {
                case UnwrittenDebug:
                        fprintf( this->m_pFileHandle, "[DEBUG]       " );
                        break;
                case UnwrittenInformation:
                        fprintf( this->m_pFileHandle, "[INFORMATION] " );
                        break;
                case UnwrittenWarning:
                        fprintf( this->m_pFileHandle, "[WARNING]     " );
                        break;
                case UnwrittenError:
                        fprintf( this->m_pFileHandle, "[ERROR]       " );
                        break;
        }
}

void UnwrittenLogfile::Write( UnwrittenLoggingType typeOfMsg, const char * szText, ... )
{
        // the needed va_list
        va_list ap;

        // check if the handle is not NULL
        assert( this->m_pFileHandle != NULL );

        // print the given text
        if( typeOfMsg >= this->m_eLoggingType )
        {
                // print the message type (if the flag is set)
                if( this->m_bPrintMessageType && !this->m_bWaitForNewLine )
                        this->PrintMessageType( typeOfMsg );

                // print the message
                va_start( ap, szText );
                vfprintf( this->m_pFileHandle, szText, ap );
                va_end( ap );

                // say that we wait for a new line
                this->m_bWaitForNewLine = true;
        }
}

void UnwrittenLogfile::WriteLine( UnwrittenLoggingType typeOfMsg, const char * szText, ... )
{
        // the needed va_list
        va_list ap;

        // check if the handle is not NULL
        assert( this->m_pFileHandle != NULL );

        // print the given text with an tailing \n
        if( typeOfMsg >= this->m_eLoggingType )
        {
                // print the message type (if the flag is set)
                if( this->m_bPrintMessageType && !this->m_bWaitForNewLine )
                        this->PrintMessageType( typeOfMsg );

                // print the message
                va_start( ap, szText );
                vfprintf( this->m_pFileHandle, szText, ap );
                fprintf( this->m_pFileHandle, "\n" );
                va_end( ap );
        }

        // a new line was written
        this->m_bWaitForNewLine = false;
}

void UnwrittenLogfile::Flush()
{
        // check if the handle is not NULL
        assert( this->m_pFileHandle != NULL );

        // flush the buffer
        fflush( this->m_pFileHandle );
}

---