Logger.h

Go to the documentation of this file.

/*
 * $Revision: 2027 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2010-09-01 11:55:17 +0200 (Wed, 01 Sep 2010) $ 
 ***************************************************************/
 
#ifndef OGDF_LOGGER_H
#define OGDF_LOGGER_H

#include <ogdf/basic/basic.h>

namespace ogdf {


class OGDF_EXPORT Logger {

public:
    enum Level { LL_MINOR, LL_MEDIUM, LL_DEFAULT, LL_HIGH, LL_ALARM, LL_FORCE };
    enum LogMode { LM_GLOBAL, LM_GLOBALLOG, LM_LOG, LM_STATISTIC };

    // CONSTRUCTORS //////////////////////////////////////
    Logger() : 
        m_loglevel(m_globalloglevel), m_logmode(LM_GLOBAL) {}
    Logger(LogMode m) : 
        m_loglevel(m_globalloglevel), m_logmode(m) {}
    Logger(Level l) : 
        m_loglevel(l), m_logmode(LM_GLOBAL) {}
    Logger(LogMode m, Level l) : 
        m_loglevel(l), m_logmode(m) {}

    // USAGE //////////////////////////////////////
    std::ostream& lout(Level l = LL_DEFAULT) const { 
        return ((!m_globalstatisticmode && m_logmode==LM_GLOBAL) || m_logmode==LM_GLOBALLOG)
               ? ( (l >= m_globalloglevel) ? *world : nirvana ) 
               : ( (m_logmode==LM_LOG && l >= m_loglevel && l >= m_minimumloglevel) ? *world : nirvana );
    }
    std::ostream& sout() const { 
        return ((m_globalstatisticmode && m_logmode==LM_GLOBAL) || (m_logmode == LM_STATISTIC)) ? *world : nirvana;
    }
    std::ostream& fout() const { 
        return sfout();
    }
    
    // STATIC USAGE ///////////////////////////////
    static std::ostream& slout(Level l = LL_DEFAULT) { 
        return ((!m_globalstatisticmode) && l >= m_globalloglevel) ? *world : nirvana;
    }
    static std::ostream& ssout() { 
        return (m_globalstatisticmode) ? *world : nirvana;
    }
    static std::ostream& sfout() { 
        return *world;
    }
    
    // LOCAL //////////////////////////////////////
    Level localLogLevel() const { 
        return m_loglevel;
    }
    void localLogLevel(Level l) {
        m_loglevel = l;
    }
    LogMode localLogMode() const { 
        return m_logmode;
    }
    void localLogMode(LogMode m) {
        m_logmode = m;
    }

    // GLOBAL //////////////////////////////////////
    static Level globalLogLevel() { return m_globalloglevel; }
    static void globalLogLevel(Level l) { if(l>=m_minimumloglevel) m_globalloglevel = l; }

    static Level globalMinimumLogLevel() { return m_minimumloglevel; }
    static void globalMinimumLogLevel(Level l) { if(l<=m_globalloglevel) m_minimumloglevel = l; }
    
    static bool globalStatisticMode() { return m_globalstatisticmode; }
    static void globalStatisticMode(bool s) { m_globalstatisticmode = s; }
    
    static void setWorldStream(std::ostream& o) { world = &o; }

    // EFFECTIVE //////////////////////////////////////
    Level effectiveLogLevel() const { 
        if(m_logmode==LM_GLOBAL || m_logmode==LM_GLOBALLOG)
            return m_globalloglevel;
        else
            return (m_loglevel > m_minimumloglevel) ? m_loglevel : m_minimumloglevel;
    }
    
    bool effectiveStatisticMode() const { 
        return m_logmode==LM_STATISTIC || (m_logmode==LM_GLOBAL && m_globalstatisticmode);
    }
    

private:    
    static std::ostream nirvana;
    static std::ostream* world; 

    static Level m_globalloglevel;
    static Level m_minimumloglevel;
    static bool m_globalstatisticmode;

    Level m_loglevel;
    LogMode m_logmode;
};

}

#endif // OGDF_LOGGER_H