Logger.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/basic.h>
 
#include <algorithm>
#include <ostream>
#include <string>
 
namespace ogdf {
 
 
class Logger {
public:
    enum class Level { Minor, Medium, Default, High, Alarm, Force };
    enum class LogMode {
        Global,
        GlobalLog,
        Log,
        Statistic
    };
 
    class Indent {
        Logger* m_log;
        int m_by;
 
    public:
        explicit Indent(Logger* log, int by = 1) : m_log(log), m_by(by) { m_log->indent(m_by); }
 
        explicit Indent(Logger& log, int by = 1) : m_log(&log), m_by(by) { m_log->indent(m_by); }
 
        Indent(const Indent& copy) = delete;
 
        Indent& operator=(const Indent& other) = delete;
 
        ~Indent() { m_log->dedent(m_by); }
    };
 
    Logger() : Logger(LogMode::Global, m_globalloglevel) { }
 
    explicit Logger(LogMode m) : Logger(m, m_globalloglevel) { }
 
    explicit Logger(Level level) : Logger(LogMode::Log, level) { }
 
    Logger(LogMode m, Level level) : m_loglevel(level), m_logmode(m), m_indent(0) { }
 
 
    bool is_lout(Level level = Level::Default) const {
        bool globalNotStatistic = !m_globalstatisticmode && m_logmode == LogMode::Global;
        if (globalNotStatistic || m_logmode == LogMode::GlobalLog) {
            return level >= m_globalloglevel;
        } else {
            return m_logmode == LogMode::Log && level >= std::max(m_loglevel, m_minimumloglevel);
        }
    }
 
    std::ostream& lout(Level level = Level::Default, bool indent = true) const {
        if (is_lout(level)) {
            if (indent && m_indent > 0) {
                return *world << std::string(m_indent, '\t');
            } else {
                return *world;
            }
        } else {
            return nirvana;
        }
    }
 
    std::ostream& sout() const {
        return (m_globalstatisticmode && m_logmode == LogMode::Global)
                        || m_logmode == LogMode::Statistic
                ? *world
                : nirvana;
    }
 
    std::ostream& fout() const { return sfout(); }
 
 
    static bool is_slout(Level level = Level::Default) {
        return !m_globalstatisticmode && level >= m_globalloglevel;
    }
 
    static std::ostream& slout(Level level = Level::Default) {
        return is_slout(level) ? *world : nirvana;
    }
 
    static std::ostream& ssout() { return m_globalstatisticmode ? *world : nirvana; }
 
    static std::ostream& sfout() { return *world; }
 
 
    static bool is_ilout(Level level = Level::Default) {
        return !m_globalstatisticmode && level >= m_globallibraryloglevel;
    }
 
    static std::ostream& ilout(Level level = Level::Default) {
        return is_ilout(level) ? *world : nirvana;
    }
 
    static std::ostream& ifout() { return *world; }
 
 
    Level localLogLevel() const { return m_loglevel; }
 
    void localLogLevel(Level level) { m_loglevel = level; }
 
    LogMode localLogMode() const { return m_logmode; }
 
    void localLogMode(LogMode m) { m_logmode = m; }
 
    void indent(int by = 1) { setIndent(m_indent + by); }
 
    void dedent(int by = 1) { setIndent(m_indent - by); }
 
    int getIndent() const { return m_indent; }
 
    void setIndent(int indent) { m_indent = std::max(0, indent); }
 
 
    static Level globalLogLevel() { return m_globalloglevel; }
 
    static void globalLogLevel(Level level) {
        m_globalloglevel = level;
        if (m_globalloglevel < m_minimumloglevel) {
            m_minimumloglevel = m_globalloglevel;
        }
    }
 
    static Level globalInternalLibraryLogLevel() { return m_globallibraryloglevel; }
 
    static void globalInternalLibraryLogLevel(Level level) { m_globallibraryloglevel = level; }
 
    static Level globalMinimumLogLevel() { return m_minimumloglevel; }
 
    static void globalMinimumLogLevel(Level level) {
        m_minimumloglevel = level;
        if (m_globalloglevel < m_minimumloglevel) {
            m_globalloglevel = m_minimumloglevel;
        }
    }
 
    static bool globalStatisticMode() { return m_globalstatisticmode; }
 
    static void globalStatisticMode(bool s) { m_globalstatisticmode = s; }
 
    static void setWorldStream(std::ostream& o) { world = &o; }
 
 
    Level effectiveLogLevel() const {
        if (m_logmode == LogMode::Global || m_logmode == LogMode::GlobalLog) {
            return m_globalloglevel;
        } else {
            return (m_loglevel > m_minimumloglevel) ? m_loglevel : m_minimumloglevel;
        }
    }
 
    bool effectiveStatisticMode() const {
        return m_logmode == LogMode::Statistic
                || (m_logmode == LogMode::Global && m_globalstatisticmode);
    }
 
 
private:
    static OGDF_EXPORT std::ostream nirvana;
    static OGDF_EXPORT std::ostream* world;
 
    static OGDF_EXPORT Level m_globalloglevel;
    static OGDF_EXPORT Level m_globallibraryloglevel;
    static OGDF_EXPORT Level m_minimumloglevel;
    static OGDF_EXPORT bool m_globalstatisticmode;
 
    Level m_loglevel;
    LogMode m_logmode;
    int m_indent;
};
 
inline std::ostream& operator<<(std::ostream& os, Logger::Level level) {
    switch (level) {
    case Logger::Level::Minor:
        os << "Minor";
        break;
    case Logger::Level::Medium:
        os << "Medium";
        break;
    case Logger::Level::Default:
        os << "Default";
        break;
    case Logger::Level::High:
        os << "High";
        break;
    case Logger::Level::Alarm:
        os << "Alarm";
        break;
    case Logger::Level::Force:
        os << "Force";
        break;
    }
    return os;
}
 
}