LogManager.hh

Go to the documentation of this file.
00001 #ifndef SLIC_LOGMANAGER_HH
00002 #define SLIC_LOGMANAGER_HH 1
00003 
00004 // slic
00005 #include "LogStream.hh"
00006 #include "LogMessenger.hh"
00007 #include "Singleton.hh"
00008 
00009 // geant4
00010 #include "G4UIdirectory.hh"
00011 
00012 // stl
00013 #include <algorithm>
00014 #include <vector>
00015 #include <map>
00016 
00017 namespace slic
00018 {
00026     class LogManager : public Singleton<LogManager>
00027     {
00028 
00029         private:
00030 
00031             // LogStream vector.
00032             typedef std::vector<LogStream*> LogList;
00033 
00034             // LogStream vector iterator.
00035             typedef LogList::iterator LogListIterator;
00036             
00037             // LogMessenger vector.
00038             typedef std::vector<LogMessenger*> LogMessengerList;
00039 
00040             // LogMessenger vector iterator.
00041             typedef LogMessengerList::iterator LogMessengerListIterator;
00042 
00043             // Name to LogStream map.
00044             typedef std::map<std::string, LogStream*> LogNameMap;
00045 
00046             // LogMessenger to LogStream map.
00047             typedef std::map<LogStream*, LogMessenger*> LogMessengerMap;
00048 
00049         public:
00050 
00051             LogManager()
00052             {
00053                 m_logDir = new G4UIdirectory( "/log/" );
00054                 m_logDir->SetGuidance( "Commands for changing log output settings. [SLIC]" );
00055             }
00056 
00057             virtual ~LogManager()
00058             {
00059                 delete m_logDir;
00060             }
00061 
00062         public:
00063 
00067             LogStream* createLog( std::string name = "NONE",
00068                                   LOG::ELevel level = LOG::okay,
00069                                   ostream* os = &std::cout)
00070             {
00071                 LogStream *l = new LogStream( name, level, os );
00072                 m_logs.push_back( l );                
00073                 m_logNameMap[ name ] = l;
00074                 return l;
00075             }
00076 
00081             LogStream* createLogWithMessenger( std::string name = "NONE",
00082                                                LOG::ELevel level = LOG::okay,
00083                                                ostream* os = &std::cout)
00084             {
00085                 LogStream *l = createLog( name, level, os );
00086                 createLogMessenger( l );
00087                 return l;
00088             }
00089 
00093             void removeLog( LogStream *log )
00094             {
00095                 if ( log == 0 ) return;
00096                 LogListIterator it = findLog( log );
00097                 if ( it != m_logs.end() ) 
00098                 {
00099                     LogStream *l = (*it);
00100 
00101                     // Delete the LogStream's messenger, if it exists.
00102                     LogMessenger *lm = findLogMessenger( l );
00103                     if ( lm != 0 )
00104                     {
00105                         removeLogMessenger( lm );
00106                     }
00107 
00108                     // Delete the LogStream object.
00109                     delete (*it);
00110 
00111                     // Remove the LogStream entry.
00112                     m_logs.erase( it );
00113                 }
00114             }        
00115 
00116         private:
00117 
00121             LogMessenger* createLogMessenger( LogStream *l )
00122             {
00123                 // Check for and return an existing LogMessenger.
00124                 LogMessenger *check = findLogMessenger( l );
00125                 if ( check != 0 )
00126                 {
00127                     return check;
00128                 }
00129 
00130                 // Make a new LogMessenger.
00131                 LogMessenger *lm = new LogMessenger( l );
00132                 m_messengers.push_back( lm );
00133                 m_logMessengerMap[ l ] = lm;
00134                 return lm;
00135             }
00136 
00140             void removeLogMessenger( LogMessenger *lm )
00141             {
00142                 if ( lm == 0 ) return;
00143                 LogMessengerListIterator it = findLogMessenger( lm );
00144                 if ( it != m_messengers.end() ) 
00145                 {
00146                     delete (*it);
00147                     m_messengers.erase( it );
00148                 }                
00149             }
00150 
00154             LogStream* findLog( const std::string &name )
00155             {
00156                 return m_logNameMap[ name ];
00157             }
00158 
00162             LogListIterator findLog( LogStream *log )
00163             {
00164                 if ( log == 0 ) return m_logs.end();
00165                 return find( m_logs.begin(), m_logs.end(), log );
00166             }
00167 
00171             LogMessengerListIterator findLogMessenger( LogMessenger *lm )
00172             {
00173                 if ( lm == 0 ) return m_messengers.end();
00174                 return find( m_messengers.begin(), m_messengers.end(), lm );
00175             }
00176 
00180             LogMessenger* findLogMessenger( LogStream *s )
00181             {
00182                 return m_logMessengerMap[ s ];
00183             }
00184             
00185             friend class LogStream;
00186 
00187         private:
00188             LogList m_logs;
00189             LogMessengerList m_messengers;
00190             LogNameMap m_logNameMap;
00191             LogMessengerMap m_logMessengerMap;
00192 
00193             G4UIdirectory *m_logDir;
00194     };
00195 }
00196 
00197 
00198 #endif

Generated on Mon Jun 7 17:45:20 2010 for Simulator for the Linear Collider by  doxygen 1.5.4