Logger.h

Go to the documentation of this file.

#ifndef LOGGER_H
#define LOGGER_H

#include <vrecko/Export>
#include <vrecko/Timer.h>
#include <vrecko/BenchmarkWriter.h>
#include <fstream>
#include <map>
#include <helpers/DynamicArray.h>
#include <string>
#include <vrecko/MTLock.h>

#include <windows.h>

namespace vrecko {

class logger_streambuf;


// Flags for Logger::dwAllowedOutput etc.
#define LOGGER_OUTPUTTYPE_ERROR                 0x00000001
    // Error message
#define LOGGER_OUTPUTTYPE_WARNING               0x00000002
    // Warning
#define LOGGER_OUTPUTTYPE_NOTICE                0x00000004
    // Simple notice
#define LOGGER_OUTPUTTYPE_DEBUG                 0x00000008
    // Debug message - won't be shown in normal user setup
#define LOGGER_OUTPUTTYPE_DEBUGFILE             0x00000010
    // Debug message outputted only into the log file
#define LOGGER_OUTPUTTYPE_DEBUGFLUSH            0x00000020
    // Debug message that is processed immediately, even in non-main thread.
    // Otherwise the message is handed over to the main thread and processed there.
#define LOGGER_OUTPUTTYPE_TIMINGSFILE           0x00000040
    // Special constant to output times into the timings file (which is xml-based)

#define LOGGER_OUTPUTTYPEMASK_ALL               0xFFFFFFFF
#define LOGGER_OUTPUTTYPEMASK_NONE              0x00000000
#define LOGGER_OUTPUTTYPEMASK_DEBUG             LOGGER_OUTPUTTYPEMASK_ALL
#define LOGGER_OUTPUTTYPEMASK_USER              (LOGGER_OUTPUTTYPE_ERROR | LOGGER_OUTPUTTYPE_WARNING | LOGGER_OUTPUTTYPE_NOTICE)
#define LOGGER_OUTPUTTYPEMASK_NORMAL            LOGGER_OUTPUTTYPEMASK_USER

#define LOGGER_OT_INTERNALMASK_SPECIALTYPES     (LOGGER_OUTPUTTYPE_TIMINGSFILE)
#define LOGGER_OT_INTERNALMASK_NORMALTYPES      (0xFFFFFFFF ^ LOGGER_OT_INTERNALMASK_SPECIALTYPES)


// Constants for Logger:dwOutputDest etc.
#define LOGGER_OUTPUTDEST_STDOUT                0x00000001 // text console
#define LOGGER_OUTPUTDEST_FILE                  0x00000002 // log file
#define LOGGER_OUTPUTDEST_DEBUGSTRING           0x00000004 // i.e. using OutputDebugString() to print it on VisutalStudio console.

#define LOGGER_OUTPUTDESTMASK_ALL               0xFFFFFFFF // all output destinations
#define LOGGER_OUTPUTDESTMASK_NONE              0x00000000
#define LOGGER_OUTPUTDESTMASK_NO_STDOUT         (LOGGER_OUTPUTDESTMASK_ALL ^ LOGGER_OUTPUTDEST_STDOUT)
#define LOGGER_OUTPUTDESTMASK_NO_FILE           (LOGGER_OUTPUTDESTMASK_ALL ^ LOGGER_OUTPUTDEST_FILE)
#define LOGGER_OUTPUTDESTMASK_NO_DEBUGSTRING    (LOGGER_OUTPUTDESTMASK_ALL ^ LOGGER_OUTPUTDEST_DEBUGSTRING)




class VRECKO_EXPORT Logger {
    friend class World;
public:
    Logger();
    ~Logger();

    bool init();
        // The initialization must be done from the main thread, because Logger will remember its ID
        // and notices from other threads will be postponed and processed in the main thread.

    void done();

    void update();
        // Should be called sometimes (ex. once/twice per frame) to process any possible outstanding texts.

    void noticeLog(const char *notice = "", ...);
    void vnoticeLog(const char *notice, va_list args);
//  void noticeLog(int level, const char *notice = "", ...);
//  void vnoticeLog(int level, const char *notice, va_list args);
    void warningLog(const char *warning = "", ...);
    void vwarningLog(const char *warning, va_list args);
//  void warningLog(int level, const char *warning = "", ...);
//  void vwarningLog(int level, const char *warning, va_list args);
    void errorLog(const char *error = "", ...);
    void verrorLog(const char *error, va_list args);
//  void errorLog(int level, const char *error = "", ...);
//  void verrorLog(int level, const char *error, va_list args);
    void debugLog(const char *debugText = "", ...);
    void vdebugLog(const char *debugText, va_list args);
    // The (v)debugFileLog() functions only write info to the file
    void debugFileLog(const char *debugText = "", ...);
    void vdebugFileLog(const char *debugText, va_list args);

    void debugFlush(const char *debugText = "", ...);
    void vdebugFlush(const char *debugText, va_list args);
        // Causes the text to be outputted immediately, even in a non-main thread

    inline unsigned long getAllowedOutput() { return dwAllowedOutput; }
    inline void setAllowedOutput(unsigned long dwNewOutput) { dwAllowedOutput = dwNewOutput; }
        // [dwNewOutput] is a combination of LOGGER_OUTPUTTYPE_*.
        // It is possible to use one of LOGGER_OUTPUTTYPEMASK_* to initialize one of the default behaviours.

    inline unsigned long getOutputDest() { return dwOutputDest; }
    inline void setOutputDest(unsigned long dwNewOutputDest) { dwOutputDest = dwNewOutputDest; }
        // [dwNewOutputDest] is a combination of LOGGER_OUTPUTDEST_*

    void startTiming(std::string sectionName);
    void stopTiming(std::string sectionName, DWORD dwOutputType = LOGGER_OUTPUTTYPE_DEBUG);
        // LOGGER_OUTPUTTYPE_TIMINGSFILE can be used to output the value into the xml-based
        // timings file.

    void writeBMCounter(const char *pName, float fValue);
        // Writes out a counter value to the xml-based timings file.
        //
        // BEWARE! If this method is used in a NON-MAIN thread it's not a problem,
        //      but counters are cached and written into file in main thread.
        //      To prevent overflowing there is a LIMIT on number of waiting counter writes.

    inline osg::Timer_t tick() { return vrecko::Timer::instance()->tick(); };

    typedef void (*OutputNotificationFuncType)(unsigned long dwOutputType, const char *outputLine, void* userParam);

    bool registerOutputNotification(OutputNotificationFuncType aFunc, void* userParam);
    bool unregisterOutputNotification(OutputNotificationFuncType aFunc);

protected:
    std::ofstream log_file;
    osg::Timer_t starttime_stamp;

    DWORD dwMainThreadId;
        // Used to determine whether the current call to one of the ...log() methods
        // should output the message directly or pospone it to be processed
        // in a different (main) thread.

    MTLock generalLock;

    BenchmarkWriter bm;

    class OutstandingText {
    public:
        unsigned long dwOutputType;
        std::string str;
    };
    DynamicArray<OutstandingText> outstandingTexts;

    class OutstandingCounter {
    public:
        unsigned int time; // ms
        std::string strName;
        float fValue;
    };
    DynamicArray<OutstandingCounter> outstandingCounters[2];
        // two arrays: One is processed in the main thread and written to the file
        // and the other can be filled by other threads.
    int countersActiveIndex;
        // Index of the array that is being WRITTEN to.
    MTLock countersActiveLock;

    void addOutstandingText(unsigned long dwOutputType, const char *buffer);
        // This method expects that the caller has already locked the [generalLock]
    void processOutstandingTexts();
        // This method expects that the caller has already locked the [generalLock]

    void writeBMCounterLowLevel(unsigned int time, const char *pName, float fValue);
        // This method expects that the caller has already locked the necessary lock(s)

    void processOutstandingCounters();
        // Flushes outstanding counters into file.
        // Can be called only from the main thread.


    void processTextMain(unsigned long dwOutputType, const char *buffer);
        // This method expects that the caller has already locked the [generalLock]

    bool openBenchmarkFile();
        // This function does nothing if the file is already opened (and returns true).
        // Otherwise returns false if an error occur.
        // NOTE: The method assumes the benchmarkFile lock is already taken,


    struct OutputNotificationFuncStored {
        OutputNotificationFuncType outFunc;
        void *userParam;
    };


    struct TimingInfo {
        TimingInfo() { startTime = 0; totalTime = 0; numRuns = 0; }

        osg::Timer_t startTime;

        // for statistics across multiple timings
        osg::Timer_t totalTime;
        int numRuns;
    };

    std::map<std::string, TimingInfo, std::less<std::string> > sectionsTiming;
    DynamicArray<OutputNotificationFuncStored> outFuncs;

    logger_streambuf *new_cout, *new_cerr;
    std::streambuf *old_cout_buf, *old_cerr_buf;
    std::ostream *old_cout;

    unsigned long dwAllowedOutput;
        // combination of LOGGER_OUTPUTTYPE_*

    unsigned long dwOutputDest;
        // combination of LOGGER_OUTPUTDEST_*

    HANDLE hOriginalStdHandle;
        // Handle of the original stdout to allow us to change colors
    WORD wOriginalConsoleAttributes;
        // we will be changing the color of console output, so here is the original color to restore it

    void textLog(unsigned long dwOutputType, const char *text = "", ...);
    void vtextLog(unsigned long dwOutputType, const char *text, va_list args);
        // [dwOutputType] is one of LOGGER_OUTPUTTYPE_
};

extern VRECKO_EXPORT Logger logger;


#ifdef _DEBUG
    #define OUTPUTSTR(str) logger.debugLog(str);
    #define OUTPUTSTR2(str, p1) logger.debugLog((str), (p1));
    #define OUTPUTSTR3(str, p1, p2) logger.debugLog((str), (p1), (p2));
    #define OUTPUTSTR4(str, p1, p2, p3) logger.debugLog((str), (p1), (p2), (p3));
    #define OUTPUTSTR5(str, p1, p2, p3, p4) logger.debugLog((str), (p1), (p2), (p3), (p4));
    #define OUTPUTSTR6(str, p1, p2, p3, p4, p5) logger.debugLog((str), (p1), (p2), (p3), (p4), (p5));
    #define OUTPUTSTR7(str, p1, p2, p3, p4, p5, p6) logger.debugLog((str), (p1), (p2), (p3), (p4), (p5), (p6));

    #define STARTTIMING(sectionName) logger.startTiming(sectionName);
    #define STOPTIMING(sectionName) logger.stopTiming(sectionName);
#else
    #define OUTPUTSTR(str) {}
    #define OUTPUTSTR2(str, p1) {}
    #define OUTPUTSTR3(str, p1, p2) {}
    #define OUTPUTSTR4(str, p1, p2, p3) {}
    #define OUTPUTSTR5(str, p1, p2, p3, p4) {}
    #define OUTPUTSTR6(str, p1, p2, p3, p4, p5) {}
    #define OUTPUTSTR7(str, p1, p2, p3, p4, p5, p6) {}

    #define STARTTIMING(sectionName)
    #define STOPTIMING(sectionName)
#endif


};

#endif