CeylanLogAggregator.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the Ceylan library.
 *
 * The Ceylan library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option) 
 * any later version.
 *
 * The Ceylan 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 and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and the GNU General Public License along with the Ceylan library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef CEYLAN_LOG_AGGREGATOR_H_
#define CEYLAN_LOG_AGGREGATOR_H_


#include "CeylanTextDisplayable.h"  // for inheritance
#include "CeylanLog.h"              // for LogException


#include <string>
#include <list>



namespace Ceylan
{

    
    namespace Log
    {
    
    
        // A container for basic Log messages.
        class LogChannel ;
        
        
        class ObjectChannel ;
        
        
        // What a LogAggregator aggregates.
        class LogMessage ;
        
        
        
        class CEYLAN_DLL LogAggregator : public TextDisplayable
        {
        
        
            public:
            
            
                class LogAggregatorException : public LogException
                {
                    public:
                    
                        explicit LogAggregatorException( 
                            const std::string & message ) ; 
                            
                        virtual ~LogAggregatorException() throw() ;
                        
                } ;
                
            
            
                explicit LogAggregator( bool useGlobalLevelOfDetail = true, 
                    bool beSmart = true ) ;
                    
                            
                virtual ~LogAggregator() throw() ;
        
        
                
                virtual LogChannel & createBasicChannel( 
                    const std::string & channelName ) ;

                
                
                virtual ObjectChannel & createObjectChannel( 
                    LogMessage & message ) ;



                virtual void aggregate() = 0 ;
                
                
                    
                virtual bool hasChannel( const std::string & channelName ) 
                    const ;
                    
                    
                    
                virtual LogChannel * findChannel( 
                    const std::string & channelName ) const ;
                 
                 
                 
                virtual void transferChannel( LogChannel & source, 
                    LogChannel & target ) ;
                 
                 
                
                virtual void removeChannel( LogChannel & target ) ;
                
                
                
                virtual void store( LogMessage & message ) ; 
            
            
            
                virtual const std::string toString( 
                    Ceylan::VerbosityLevels level = Ceylan::high ) const ;
                    
                    

                static const LevelOfDetail DefaultGlobalLevelOfDetail ;
                
                 
                 
            
            protected:


                virtual LogChannel * findBasicChannel( 
                    const std::string & basicChannelName ) const ;
            
            
            
                virtual ObjectChannel * findObjectChannel( 
                    const std::string & nonPrefixedChannelName ) const ;
            
            
            
                virtual void createBasicChannelFrom( LogMessage & message ) ;
                
                
                
                virtual void createLoggableChannelFrom( LogMessage & message ) ;
                
                
                
                virtual void storeBasicMessage( LogMessage & basicLogMessage ) ;
                
                
                
                virtual void storeObjectMessage( 
                    LogMessage & objectLogMessage ) ; 
            
            
            
                virtual void demangle( LogMessage & objectLogMessage ) ;


                
                 virtual Ceylan::VerbosityLevels 
                    getOverallVerbosityLevel() const ;
                 
                 
                 virtual Ceylan::VerbosityLevels getMessageVerbosityLevel( 
                        const LogMessage & message ) const ;             
                
                
                
                static Ceylan::VerbosityLevels
                    ConvertListenerLevelOfDetailToVerbosityLevel( 
                        LevelOfDetail level ) ; 
                
                
                static Ceylan::VerbosityLevels
                    ConvertMessageLevelOfDetailToVerbosityLevel( 
                        LevelOfDetail level ) ; 
                
                
#pragma warning( push )
#pragma warning( disable : 4251 )

                std::list<LogChannel *> _channelList ;

#pragma warning( pop ) 
                
                
                bool _beSmart ;
        
        
                bool _useGlobalLevelOfDetail ; 
                
                
                LevelOfDetail _globalLevelOfDetail ;

        
        
        private:
        
        
                LogAggregator( const LogAggregator & source ) ;
            
            
                LogAggregator & operator = ( const LogAggregator & source ) ;
                
                
                
        } ;
    
    
    }


}


#endif // CEYLAN_LOG_AGGREGATOR_H_

---