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:
 
        typedef std::vector<LogStream*> LogList;
 
        typedef LogList::iterator LogListIterator;
 
        typedef std::vector<LogMessenger*> LogMessengerList;
 
        typedef LogMessengerList::iterator LogMessengerListIterator;
 
        typedef std::map<std::string, LogStream*> LogNameMap;
 
        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