ADFCentralLog.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#include <iostream>

#include "ADFLogCollector.h"
#include "ADFCentralLog.h"

using namespace ADF;

CentralLogDestroyer CentralLog::gTheCentralLogDestroyer;
CentralLog *CentralLog::gTheCentralLog = 0x0;

CentralLogDestroyer::CentralLogDestroyer (CentralLog* s)
{
        fCentralLog = s;
}

CentralLogDestroyer::~CentralLogDestroyer ()
{
         if (fCentralLog) 
                delete fCentralLog;

        fCentralLog = 0x0;
}

void CentralLogDestroyer::SetCentralLog(CentralLog *log) 
{
        fCentralLog = log;
}
    
CentralLog::CentralLog() :
        fCurrentCollector(0x0),
        fListOfCollectors()
{
#ifdef DEBUGSTATIC      
        std::clog << "[[static]] CentralLog::CentralLog() ]\n[...\n" ;
        std::clog << " Default collectors are built " << std::endl;
#endif
        
        Add ( new LogCollector("Null",true) );
        Add ( new OStreamCollector("cout",true) );

        // default is clog
        ChangeCollector("cout");

#ifdef DEBUGSTATIC      
        std::clog << "...]" << std::endl;
#endif  
} 

CentralLog::~CentralLog() 
{
#ifdef DEBUGSTATIC              
        std::clog << "[[static]] CentralLog::~CentralLog() ]\n[...\n" ;
        std::clog << " Collectors owned by Central Log are deleted " << std::endl;
#endif  
        
        fCurrentCollector = 0x0; 
        
        // loop to check the name does not yet exist
        std::list< LogCollector * >::iterator 
                listed_item; 
        for ( listed_item = fListOfCollectors.begin() ; listed_item != fListOfCollectors.end() ; listed_item++ ) {
                if ( (*listed_item)->IsDeleteByCentralLog() ) { 
#ifdef DEBUGSTATIC      
                        std::clog << " --> " << (*listed_item)->GetName() 
                                  << " deleted from the central log ... ";      
#endif  
                        delete (*listed_item);
#ifdef DEBUGSTATIC      
                        std::clog << " ... done " << std::endl; 
#endif  
                }       
        }       
#ifdef DEBUGSTATIC                                      
        std::clog << "...]" << std::endl;
#endif  

}  

CentralLog *CentralLog::theCentralLog()
{ 
        if ( gTheCentralLog == 0x0 ) {
                gTheCentralLog = new CentralLog();
                gTheCentralLogDestroyer.SetCentralLog (gTheCentralLog) ; 
        }
        
        return gTheCentralLog; 
}

bool CentralLog::ChangeCollector(std::string whichlog)
{
        bool ok = false;
        
        // loop to check the name does not yet exist
        std::list< LogCollector * >::iterator 
                listed_item; 
        for ( listed_item = fListOfCollectors.begin() ; listed_item != fListOfCollectors.end() ; listed_item++ ) {
                if ( (*listed_item)->GetName() == whichlog ) { 
                        fCurrentCollector =  (*listed_item);
                        ok = true;
                        
                        break;
                }       
        }
        if ( ok )
                std::clog << "[[info]] CentralLog::ChangeCollector() ] [ "
                          << fCurrentCollector->GetName() << " is now the current collector ]" << std::endl;    
        
        return ok;
}

bool CentralLog::IsCollector(std::string whichlog)
{
        bool ok = false;
        
        // loop to check the name does not yet exist
        std::list< LogCollector * >::iterator 
                listed_item; 
        for ( listed_item = fListOfCollectors.begin() ; listed_item != fListOfCollectors.end() ; listed_item++ ) {
                if ( (*listed_item)->GetName() == whichlog ) { 
                        fCurrentCollector =  (*listed_item);
                        ok = true;
                        
                        break;
                }       
        }

        return ok;
}
    
LogCollector *CentralLog::GetCurrentLogCollector() const
{
        return fCurrentCollector;
}       
        
LogCollector *CentralLog::Add ( LogCollector * acollector )
{
        LogCollector *toremove = 0x0;
        
#ifdef DEBUGSTATIC      
        std::clog << "[[info]] CentralLog::Add() ] [ ";
#endif  
        if ( acollector == 0x0 ) {
#ifdef DEBUGSTATIC                      
                std::clog << "cannot add null collectors to the central log ]" << std::endl;
#endif  
                return toremove;
        }
                
        // loop to check the name does not yet exist
        std::list< LogCollector * >::iterator 
                listed_item; 
        for ( listed_item = fListOfCollectors.begin() ; listed_item != fListOfCollectors.end() ; listed_item++ ) {
                if ( (*listed_item)->GetName() == acollector->GetName() ) { 
                        toremove = (*listed_item);
                        break;
                }       
        }
        // already a collector with the same name, remove it from the list
        if ( toremove ) {
                fListOfCollectors.erase(listed_item);
#ifdef DEBUGSTATIC                      
                std::clog << toremove->GetName() 
                          << " removed from the central log ]" << std::endl;
#endif  

        }
        fListOfCollectors.push_back( acollector );
#ifdef DEBUGSTATIC                      
        std::clog << acollector->GetName() 
                  << " added to the central log ]" << std::endl;        
#endif  
                  
        // return removed collector if any
        return toremove;        
}