|| || || || || || || ||

---

Logger.h

Go to the documentation of this file.

#ifndef Impala_Basis_Logger_h
#define Impala_Basis_Logger_h

/*********************************************************************
 * Class: Logger
 *
 * Base logging class for registering user actions and debug messages
 *
 * Primary Author: Ork, orooij, 04-09-2006
 ********************************************************************/

#include "Basis/Timer.h"
//#include "Link/OGL/UndefLinkListMacros.h"
#include <map>
#include <iostream>
#include <sstream>
#include <fstream>


namespace Impala
{


class LogListener
{
public:
    virtual void
    LogString(String, bool isPartial, int level) = 0;

    virtual void
    EndLine(int level) = 0;
};


class LogType
{
public:
    LogType(int level, LogListener *target) 
    {
        mLevel  = level;
        mLogger = target;
    }

    LogType&
    operator<<(String log)
    {
        mLogger->LogString(log, true, mLevel);
        return *this;
    }

    template <class T>
    LogType&
    operator<<(T log)
    {
        std::ostringstream s;
        s << log;
        mLogger->LogString(s.str(), true, mLevel);
        return *this;
    }

    LogType&
    operator<<( std::ostream& (*f)(std::ostream&) )
    {
        mLogger->EndLine(mLevel);
        return *this;
    }

private:
    int mLevel;
    LogListener *mLogger;
};


class Logger : public LogListener
{
public:

    static void
    Configure(int logLevel, String logFile, bool debug)
    {
        GetInstance().Init(logLevel, logFile, debug);
    }

    static LogType
    Debug(int level=Logger::LOG_DEBUG)
    {
        return Log(level);
    }

    static LogType
    Log(int level=Logger::LOG_INFO)
    {
        return LogType(level, &Logger::GetInstance());
    }

    static LogType
    User()
    {
        return Log(Logger::LOG_USER);
    }

    static LogType
    System()
    {
        return Log(Logger::LOG_SYSTEM);
    }

    static LogType
    Error()
    {
        return Log(Logger::LOG_ERROR);
    }

    static LogType
    Warning()
    {
        return Log(Logger::LOG_WARNING);
    }

    static LogType
    Information()
    {
        return Log(Logger::LOG_INFO);
    }

    virtual
    ~Logger()
    {
        LogString("Logger destructed.");
        if (mLogToFile)
            mLog->close();
        mErrorLog->close();
    }

    static const int LOG_DEBUG   = 1;
    static const int LOG_INFO    = 2;
    static const int LOG_WARNING = 3;
    static const int LOG_ERROR   = 4;
    static const int LOG_ACTION  = 5;
    static const int LOG_SYSTEM  = 6;
    static const int LOG_USER    = 7;

    static void
    StartAction(String actionName, int level=LOG_USER)
    {
        Logger *al = &GetInstance();
        al->mActionTimes[actionName] = al->mTimer->SplitTime();
        al->mActionLevels[actionName] = level;
        std::ostringstream s;
        s << "ACTION START: " << actionName;
        al->LogString(s.str(), false, level);
    }

    static double
    EndAction(String actionName)
    {
        Logger *al = &GetInstance();
        if (al->mActionTimes.find(actionName) == al->mActionTimes.end())
        {
            Warning() << "EndAction called but no action started: "
                      << actionName << std::endl;
            return 0.0;
        }

        double delta = al->mTimer->SplitTime() - al->mActionTimes[actionName];
        std::ostringstream s;
        s << "ACTION STOP: " << actionName << ", " << delta << " seconds";
        al->LogString(s.str(), false, al->mActionLevels[actionName]);
        return delta;
    }

    static void
    OpenPartLog()
    {
        Logger *al = &GetInstance();
        al->DoOpenPartLog();
    }

    static void
    ClosePartLog(String filename)
    {
        Logger *al = &GetInstance();
        al->DoClosePartLog(filename);
    }


protected:

    virtual void
    LogString(String log, bool isPartial=false, int level=LOG_DEBUG)
    {
        if (level < mShowLevel)
            return;

        if (!mLineStarted)
        {
            std::cout << mTimer->SplitTimeStr() << " " << GetHeader(level)
                      << ": ";
            if (mLogToFile)
                *mLog << mTimer->SplitTime() <<  " " << GetHeader(level) << ": ";
            if (mPLog != 0)
                *mPLog << mTimer->SplitTime() <<  " " << GetHeader(level) << ": ";
            if (level == LOG_ERROR)
                *mErrorLog << mTimer->SplitTime() <<  " " << GetHeader(level)
                           << ": ";
        }

        std::cout << log;

        if (mLogToFile)
            *mLog << log;
        if (mPLog != 0)
            *mPLog << log;
        if (level == LOG_ERROR)
            *mErrorLog << log;

        mLineStarted = true;
        if (!isPartial)
            EndLine(level);
    }

    void
    EndLine(int level)
    {
        if (mLineStarted)
        {
            std::cout << std::endl;
            if (mLogToFile)
                *mLog << std::endl;
            if (mPLog != 0)
                *mPLog << std::endl;
            if (level == LOG_ERROR)
                *mErrorLog << std::endl;

            mLineStarted = false;
        }
    }

    String
    GetHeader(int level)
    {
        switch (level)
        {
            case LOG_DEBUG:  return "DEBUG   ";
            case LOG_INFO:   return "INFO    ";
            case LOG_WARNING:return "WARNING ";
            case LOG_ERROR:  return "ERROR   ";
            case LOG_ACTION: return "ACTION  ";
            case LOG_SYSTEM: return "SYSTEM  ";
            case LOG_USER:   return "USER    ";
        }
        return "??      ";
    }

    void
    DoOpenPartLog()
    {
        if (mPLog != 0)
        {
            LogString("DoOpenPartLog: closing last part log.");
            delete mPLog;
        }
        mPLog = new std::ostringstream();
        LogString("Partial log started.");
    }

    void
    DoClosePartLog(String filename)
    {
        std::ostringstream s;
        s << "Writing partial log to file " << filename;
        LogString(s.str());
        std::fstream f(filename.c_str(), std::ios::out);
        f << mPLog->str();
        f << std::endl;
        f.close();
        delete mPLog;
        mPLog = 0;
    }

public:

    Logger&
    operator<<(String log)
    {
        LogString(log, true, LOG_DEBUG);
        return *this;
    }

    Logger&
    operator<<( std::ostream& (*f)(std::ostream&) )
    {
        EndLine(mShowLevel);
        return *this;
    }


private:

    static Logger&
    GetInstance()
    {
        static Logger theLogger;
        return theLogger;
    }

    Logger()
    {
    }

    void
    Init(int logLevel, String logFile, bool debug)
    {
        mLineStarted = false;
        mTimer = new Timer(1);
//        mActionTimer = new Timer(1);
        mShowLevel = logLevel;
        mLogFile = logFile;
        mLogToFile = !mLogFile.empty();
        if (debug)
            mShowLevel = LOG_DEBUG;

        std::ostringstream s;
        s << "Logger started @ level " << mShowLevel;

        if (mLogToFile)
        {
            mLog = new std::fstream(mLogFile.c_str(),
                                    std::ios::out | std::ios::app);
        }
        else
        {
            mLog = 0;
        }
        mPLog = 0;
        mErrorLog = new std::fstream("errors.log", std::ios::out | std::ios::app);
        LogString(s.str());
    }

    std::map<String, double> mActionTimes;
    std::map<String, int> mActionLevels;
    String mLogFile;
    bool mLogToFile;
    bool mLineStarted;
    int mShowLevel;
    Timer *mTimer;
    std::fstream *mLog;
    std::ostringstream *mPLog;
    std::fstream *mErrorLog;

};

} // namespace Impala

#endif

---