LogManager.hh

Go to the documentation of this file.

#ifndef SLIC_LOGMANAGER_HH
#define SLIC_LOGMANAGER_HH 1

// slic
#include "LogStream.hh"
#include "LogMessenger.hh"
#include "Singleton.hh"

// geant4
#include "G4UIdirectory.hh"

// stl
#include <algorithm>
#include <vector>
#include <map>

namespace slic
{
    class LogManager : public Singleton<LogManager>
    {

        private:

            // LogStream vector.
            typedef std::vector<LogStream*> LogList;

            // LogStream vector iterator.
            typedef LogList::iterator LogListIterator;
            
            // LogMessenger vector.
            typedef std::vector<LogMessenger*> LogMessengerList;

            // LogMessenger vector iterator.
            typedef LogMessengerList::iterator LogMessengerListIterator;

            // Name to LogStream map.
            typedef std::map<std::string, LogStream*> LogNameMap;

            // LogMessenger to LogStream map.
            typedef std::map<LogStream*, LogMessenger*> LogMessengerMap;

        public:

            LogManager()
            {
                m_logDir = new G4UIdirectory( "/log/" );
                m_logDir->SetGuidance( "Commands for changing log output settings. [SLIC]" );
            }

            virtual ~LogManager()
            {
                delete m_logDir;
            }

        public:

            LogStream* createLog( std::string name = "NONE",
                                  LOG::ELevel level = LOG::okay,
                                  ostream* os = &std::cout)
            {
                LogStream *l = new LogStream( name, level, os );
                m_logs.push_back( l );                
                m_logNameMap[ name ] = l;
                return l;
            }

            LogStream* createLogWithMessenger( std::string name = "NONE",
                                               LOG::ELevel level = LOG::okay,
                                               ostream* os = &std::cout)
            {
                LogStream *l = createLog( name, level, os );
                createLogMessenger( l );
                return l;
            }

            void removeLog( LogStream *log )
            {
                if ( log == 0 ) return;
                LogListIterator it = findLog( log );
                if ( it != m_logs.end() ) 
                {
                    LogStream *l = (*it);

                    // Delete the LogStream's messenger, if it exists.
                    LogMessenger *lm = findLogMessenger( l );
                    if ( lm != 0 )
                    {
                        removeLogMessenger( lm );
                    }

                    // Delete the LogStream object.
                    delete (*it);

                    // Remove the LogStream entry.
                    m_logs.erase( it );
                }
            }        

        private:

            LogMessenger* createLogMessenger( LogStream *l )
            {
                // Check for and return an existing LogMessenger.
                LogMessenger *check = findLogMessenger( l );
                if ( check != 0 )
                {
                    return check;
                }

                // Make a new LogMessenger.
                LogMessenger *lm = new LogMessenger( l );
                m_messengers.push_back( lm );
                m_logMessengerMap[ l ] = lm;
                return lm;
            }

            void removeLogMessenger( LogMessenger *lm )
            {
                if ( lm == 0 ) return;
                LogMessengerListIterator it = findLogMessenger( lm );
                if ( it != m_messengers.end() ) 
                {
                    delete (*it);
                    m_messengers.erase( it );
                }                
            }

            LogStream* findLog( const std::string &name )
            {
                return m_logNameMap[ name ];
            }

            LogListIterator findLog( LogStream *log )
            {
                if ( log == 0 ) return m_logs.end();
                return find( m_logs.begin(), m_logs.end(), log );
            }

            LogMessengerListIterator findLogMessenger( LogMessenger *lm )
            {
                if ( lm == 0 ) return m_messengers.end();
                return find( m_messengers.begin(), m_messengers.end(), lm );
            }

            LogMessenger* findLogMessenger( LogStream *s )
            {
                return m_logMessengerMap[ s ];
            }
            
            friend class LogStream;

        private:
            LogList m_logs;
            LogMessengerList m_messengers;
            LogNameMap m_logNameMap;
            LogMessengerMap m_logMessengerMap;

            G4UIdirectory *m_logDir;
    };
}


#endif

---