E:/Projekte/Open Source/Unwritten/Unwritten C++/projects/Library/source/UnwrittenLogfileManager.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 <UnwrittenLogfileManager.hpp>
#include <assert.h>

//
// the one and only UnwrittenLogfileManager object
//
UnwrittenLogfileManager * UnwrittenLogfileManager::m_pInstance = NULL;

UnwrittenLogfileManager::UnwrittenLogfileManager()
{
}

UnwrittenLogfileManager::~UnwrittenLogfileManager()
{
}

UnwrittenLogfileManager * UnwrittenLogfileManager::GetInstance()
{
        if( UnwrittenLogfileManager::m_pInstance == NULL )
                UnwrittenLogfileManager::m_pInstance = new UnwrittenLogfileManager();
        return( UnwrittenLogfileManager::m_pInstance );
}

bool UnwrittenLogfileManager::ShouldPrintMessageType()
{
        return( this->m_bPrintMessageType );
}

void UnwrittenLogfileManager::ShouldPrintMessageType( bool bShouldPrint )
{
        this->m_bPrintMessageType = bShouldPrint;
}

void UnwrittenLogfileManager::CloseLogfile( const std::string & szFilename )
{
        // if there is no corresponding logfile in the managed list, just return
        if( this->m_pLogfiles.find( szFilename ) == this->m_pLogfiles.end() )
                return;

        // get an iterator for the given logging object
        std::map< std::string, UnwrittenLogfile * >::const_iterator i = this->m_pLogfiles.find( szFilename );

        // cast the second part of this pair, into an CLogFile class
        UnwrittenLogfile * pLogfile = static_cast< UnwrittenLogfile * >( i->second );

        // call the disposing function and destroy the object
        pLogfile->Dispose();
        delete( pLogfile );

        // remove the object from our managing list
        this->m_pLogfiles.erase( szFilename );
}

void UnwrittenLogfileManager::CloseLogfile( const UnwrittenLogfile * pLogfile )
{
        // just call the same function for filenames
        this->CloseLogfile( pLogfile->m_szLogfileName );
}

void UnwrittenLogfileManager::SetDefaultLoggingType( UnwrittenLogfile::UnwrittenLoggingType newDefaultType )
{
        // set the new default logging type
        this->m_eDefaultLoggingType = newDefaultType;
}

UnwrittenLogfile::UnwrittenLoggingType UnwrittenLogfileManager::GetDefaultLoggingType()
{
        // get the current default logging type
        return( this->m_eDefaultLoggingType );
}

UnwrittenLogfile * UnwrittenLogfileManager::GetLogfile( const std::string & szFilename )
{
        // if we have already a logfile which is managed, return it
        if( this->m_pLogfiles.find( szFilename ) != this->m_pLogfiles.end() )
        {
                // get an iterator for the given logging object
                std::map< std::string, UnwrittenLogfile * >::const_iterator i = this->m_pLogfiles.find( szFilename );

                // cast the second part of this pair, into an CLogFile class
                UnwrittenLogfile * pLogfile = static_cast< UnwrittenLogfile * >( i->second );

                // return the object
                return( pLogfile );
        }

        // else, we must create a new logfile, add it to our manager, and return it
        
        // create it and set the logging type to the default value
        UnwrittenLogfile * pLogfile = new UnwrittenLogfile( szFilename, this->m_bPrintMessageType );
        pLogfile->SetLoggingType( this->m_eDefaultLoggingType );

        // add it
        this->m_pLogfiles[ szFilename ] = pLogfile;

        // return it
        return( pLogfile );
}

void UnwrittenLogfileManager::WriteToAllFiles( UnwrittenLogfile::UnwrittenLoggingType typeOfMsg, const std::string & szText, bool bNewLine )
{
        // get the first iterator
        std::map< std::string, UnwrittenLogfile * >::const_iterator i = this->m_pLogfiles.begin();

        // iterate through all logfiles
        while( i != this->m_pLogfiles.end() )
        {
                // cast the pointer
                UnwrittenLogfile * pCurrentLogfile = static_cast< UnwrittenLogfile * >( i->second );

                // if a new line should be set, use the WriteLine function
                if( bNewLine )
                        pCurrentLogfile->WriteLine( typeOfMsg, szText.c_str() );

                // else use the Write function
                else
                        pCurrentLogfile->Write( typeOfMsg, szText.c_str() );

                // next logfile
                ++i;
        }
}

void UnwrittenLogfileManager::FlushAllFiles()
{
        // get the first iterator
        std::map< std::string, UnwrittenLogfile * >::const_iterator i = this->m_pLogfiles.begin();

        // iterate through all logfiles
        while( i != this->m_pLogfiles.end() )
        {
                // cast the pointer
                UnwrittenLogfile * pCurrentLogfile = static_cast< UnwrittenLogfile * >( i->second );

#if defined(_DEBUG)
                // if this is a debug build, write a short sync message
                pCurrentLogfile->WriteLine( UnwrittenLogfile::UnwrittenDebug, "UnwrittenLogfileManager Synchronization Event: Flushing all logfiles!" );
#endif

                // flush the file
                pCurrentLogfile->Flush();


                // next logfile
                ++i;
        }
}

size_t UnwrittenLogfileManager::GetManagedLogfiles()
{
        return( this->m_pLogfiles.size() );
}

---