+#ifndef SLIC_LOGMANAGER_HH +#define SLIC_LOGMANAGER_HH 1 + +// slic +#include "LogStream.hh" +#include "LogMessenger.hh" +#include "Singleton.hh" + +// stl +#include <algorithm> +#include <vector> +#include <map> + +namespace slic +{ + /** + * Manages LogStreams and their associated LogMessenger objects. + * This class "owns" both LogStream and LogMessenger objects, so + * neither of these classes should be deleted outside of this class. + * + * LogManager and LogStream are both friends of each other. + */ + 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() + {;} + + ~LogManager() + {;} + + public: + + /** + * Create a LogStream. + */ + 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; + } + + /** + * Create a LogMessenger attached to the given LogStream. + */ + 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; + } + + /** + * Remove a LogStream and also its LogMessenger, if it exists. + */ + 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: + + /** + * Remove a LogMessenger. + */ + void removeLogMessenger( LogMessenger *lm ) + { + if ( lm == 0 ) return; + LogMessengerListIterator it = findLogMessenger( lm ); + if ( it != m_messengers.end() ) + { + m_messengers.erase( it ); + } + } + + /** + * Find a LogStream pointer by name. + */ + LogStream* findLog( const std::string &name ) + { + return m_logNameMap[ name ]; + } + + /** + * Get position of LogStream by its pointer. + */ + LogListIterator findLog( LogStream *log ) + { + if ( log == 0 ) return m_logs.end(); + return find( m_logs.begin(), m_logs.end(), log ); + } + + /** + * Find position of LogMessenger by its pointer. + */ + LogMessengerListIterator findLogMessenger( LogMessenger *lm ) + { + if ( lm == 0 ) return m_messengers.end(); + return find( m_messengers.begin(), m_messengers.end(), lm ); + } + + /** + * Find a LogMessenger by its associated LogStream. + */ + LogMessenger* findLogMessenger( LogStream *s ) + { + return m_logMessengerMap[ s ]; + } + + friend class LogStream; + + private: + LogList m_logs; + LogMessengerList m_messengers; + LogNameMap m_logNameMap; + LogMessengerMap m_logMessengerMap; + }; +} + + +#endif

slic/include

Module.hh 1.8 -> 1.9

diff -u -r1.8 -r1.9
--- Module.hh	27 Apr 2007 01:54:32 -0000	1.8
+++ Module.hh	9 Apr 2008 22:09:35 -0000	1.9
@@ -1,10 +1,10 @@

-// $Header: /cvs/lcd/slic/include/Module.hh,v 1.8 2007/04/27 01:54:32 jeremy Exp $

+// $Header: /cvs/lcd/slic/include/Module.hh,v 1.9 2008/04/09 22:09:35 jeremy Exp $

 
 #ifndef SLIC_MODULE_HH
 #define SLIC_MODULE_HH 1
 
 // slic

-#include "LogStream.hh"

+#include "LogManager.hh"

 
 // std
 #include <string>

@@ -19,99 +19,104 @@

 
 namespace slic
 {

-  /**
-   * @class Module
-   * @brief Base class for slic modules, providing a few common functions.
-   */
-  class Module 
-  {
-  public:
-    enum ModuleStatus {
-      eOkay = 0,
-      eNotInitialized = 1,
-      eBadState = 2,
-      eFatalError = 3
-    };
-
-  protected:
-
-    /** 
-     * Only concrete Module subclasses can access the ctor.

+    /**
+     * @class Module
+     * @brief Base class for slic code modules that provides common functionality,
+     *        such as logging to an output stream.

*/

-    Module(const std::string& name, bool deleteOnExit=true, bool autoRegister=true);
-
-  public:
-    virtual ~Module();
-
-  public:
-
-    const std::string& getName() const {
-      return m_name;
-    }
-
-    const ModuleStatus getStatus() const {
-      return m_status;
-    }
-
-    virtual void initialize() 
-    {;}
-
-    virtual void reset() 
-    {;}
-
-    virtual void cleanup() 
-    {;}
-
-    bool deleteOnExit()

+    class Module

-      return m_deleteOnExit;
-    }
-
-    LogStream& log()
-    {
-      return m_log;
-    }
-
-    virtual void beginEvent( const G4Event* )
-    {;}
-
-    virtual void endEvent( const G4Event* )
-    {;}
-
-    virtual void beginRun( const G4Run* )
-    {;}
-
-    virtual void endRun( const G4Run* )
-    {;}
-
-    virtual void preTracking( const G4Track* )
-    {;}
-
-    virtual void postTracking( const G4Track* )
-    {;}    
-
-    virtual void stepping( const G4Step* ) 
-    {;}
-
-    G4ClassificationOfNewTrack stackingClassifyNewTrack( const G4Track* )
-    {
-      G4Exception("This method should never be called.  Please override it.");
-      // Arbitrary return value.  Will never reach here.
-      return fWaiting;
-    }

+        public:
+            enum ModuleStatus {
+                eOkay = 0,
+                eNotInitialized = 1,
+                eBadState = 2,
+                eFatalError = 3
+            };
+
+        protected:
+
+            /** 
+             * Only concrete Module subclasses can access the constructor. 
+             */
+            Module( const std::string& name, 
+                    bool deleteOnExit = true, 
+                    bool autoRegister = true);
+
+        public:
+            virtual ~Module();
+
+        public:
+
+            const std::string& getName() const 
+            {
+                return m_name;
+            }
+
+            const ModuleStatus getStatus() const 
+            {
+                return m_status;
+            }
+
+            virtual void initialize() 
+            {;}
+
+            virtual void reset() 
+            {;}
+
+            virtual void cleanup() 
+            {;}
+
+            bool deleteOnExit()
+            {
+                return m_deleteOnExit;
+            }
+
+            LogStream& log()
+            {
+                return *m_log;
+            }
+
+            virtual void beginEvent( const G4Event* )
+            {;}
+
+            virtual void endEvent( const G4Event* )
+            {;}
+
+            virtual void beginRun( const G4Run* )
+            {;}
+
+            virtual void endRun( const G4Run* )
+            {;}
+
+            virtual void preTracking( const G4Track* )
+            {;}
+
+            virtual void postTracking( const G4Track* )
+            {;}    
+
+            virtual void stepping( const G4Step* ) 
+            {;}
+
+            G4ClassificationOfNewTrack stackingClassifyNewTrack( const G4Track* )
+            {
+                G4Exception("This method should never be called.  Please override it.");
+                // Arbitrary return value.  Will never reach here.
+                return fWaiting;
+            }

-    void stackingNewStage()
-    {;}

+            void stackingNewStage()
+            {;}

-    void stackingPrepareNewEvent()
-    {;}

+            void stackingPrepareNewEvent()
+            {;}

-  public:
-    ModuleStatus m_status;
-    std::string m_name;
-    LogStream m_log;
-    bool m_deleteOnExit;
-  };

+        public:
+            ModuleStatus m_status;
+            std::string m_name;
+            LogStream* m_log;          
+            bool m_deleteOnExit;
+    };

 }
 
 #endif

- Module::Module( const std::string& name, bool deleteOnExit, bool autoRegister ) - : m_deleteOnExit( deleteOnExit ) - { - m_name = name; - - // Register this module with the ModuleRegistry. - if ( autoRegister ) { - ModuleRegistry::instance()->registerModule( this ); - } - - // Create a logger for this module. - m_log = LogStream( m_name, LOG::okay ); - - // Print initialization message to the log.

+ Module::Module( const std::string& name, + bool deleteOnExit, + bool autoRegister ) + : m_deleteOnExit( deleteOnExit ) + { + m_name = name; + + // If requested, register the module with the ModuleRegistry. + if ( autoRegister ) { + ModuleRegistry::instance()->registerModule( this ); + } + + // Create a logger for this module. + m_log = LogManager::instance()->createLog( m_name, LOG::okay ); + + // Create a Geant4 messenger for the logger. + LogManager::instance()->createLogMessenger( m_log ); + + // Init message.

Commit in `slic` on MAIN
`include/LogManager.hh`	+174		1.12 -> 1.13
`/LogStream.hh`	+15	-14	1.3 -> 1.4
`/Module.hh`	+95	-90	1.8 -> 1.9
`src/LogMessenger.cc`	+7	-5	1.10 -> 1.11
`/Module.cc`	+29	-23	1.5 -> 1.6
	+320	-132