wxlogger.h

Go to the documentation of this file.

#ifndef wxlogger_h
#define wxlogger_h
 
// WarpX includes
#include "wxlogrecordhandler.h"
#include "wxexcept.h"
 
// std includes
#include <iostream>
#include <map>
#include <stdexcept>
#include <string>
#include <vector>
 
// forward declare WxLogStream class
class WxLogStream;
 
template<class T> class WxLoggerBase
{
public:
    typedef std::map<std::string, T*, std::less<std::string>> LoggerMap_t;
    typedef std::pair<std::string, T*> LoggerPair_t;
 
    static T* get(const std::string& nm)
    {
 
        if (!_loggers)
            _loggers = new LoggerMap_t();
 
        // check if logger with given name is in map
        typename LoggerMap_t::iterator i = _loggers->find(nm);
        if (i != _loggers->end())
            return i->second;
 
        // it is not, so start creation process
 
        // find location of '.'
        int len = 0;
        for (int i = nm.size(); i >= 0; --i, ++len)
            if ((nm[i] == '.') || (i == 0))
            {
                // create logger with given name
                T* l = new T(nm);
                _loggers->insert(LoggerPair_t(nm, l));
                // set its parent
                if (i != 0)
                    l->_parent = WxLoggerBase<T>::get(nm.substr(0, nm.size() - len));
                return l;
            }
        // this return statement is never executed
        return 0;
    }
 
    static T* getSafe(const std::string& nm)
    {
 
        if (!_loggers)
            _loggers = new LoggerMap_t();
 
        typename LoggerMap_t::iterator i = _loggers->find(nm);
        if (i != _loggers->end())
            return i->second;
        // thow exception
        WxExcept wxe;
        wxe << "Logger " << nm << " not found";
        throw wxe;
    }
 
    static void cleanUp()
    {
        typename LoggerMap_t::iterator itr;
        if (_loggers)
        {
            for (itr = _loggers->begin(); itr != _loggers->end(); ++itr)
                delete itr->second;
            _loggers->clear();
        }
    }
 
private:
    static LoggerMap_t* _loggers;
};
// initialize maps
template<class T>
std::map<std::string, T*, std::less<std::string>>* WxLoggerBase<T>::_loggers = NULL;
 
class WxLogger : public WxLoggerBase<WxLogger>
{
public:
    friend class WxLoggerBase<WxLogger>;
 
    enum class eLevels
    {
        not_set = 0,
        debug = 10,
        info = 20,
        warning = 30,
        error = 40,
        critical = 50,
        disabled = 1000
    };
 
    // map type to map logger level to its string representation
    typedef std::map<eLevels, std::string, std::less<eLevels>> LevelMap_t;
 
    typedef std::map<std::string, eLevels, std::less<std::string>> StringMap_t;
 
    WxLogger(const std::string& name);
 
    virtual ~WxLogger();
 
    void debug(const std::string& msg) const;
 
    void info(const std::string& msg) const;
 
    void warning(const std::string& msg) const;
 
    void error(const std::string& msg) const;
 
    void critical(const std::string& msg) const;
 
    void log(const std::string& msg, eLevels withLevel) const;
 
    void setLevel(enum eLevels level);
 
    void setLevel(const std::string& level);
 
    eLevels getLevel() const;
 
    std::string getLevelStr();
 
    void addHandler(WxLogRecordHandler* handler);
 
    void disable();
 
    void enable();
 
    WxLogStream getDebugStream();
 
    WxLogStream getInfoStream();
 
    WxLogStream getWarningStream();
 
    WxLogStream getErrorStream();
 
    WxLogStream getCriticalStream();
 
private:
    WxLogger* _parent; // parent logger
    std::string _name;
    eLevels _level, _oldLevel;
    LevelMap_t _levelMap;
    StringMap_t _stringMap;
    std::vector<WxLogRecordHandler*> _handlers;
};
 
#endif // wxlogger_h