logger.h

Go to the documentation of this file.

#pragma once
 
#include <Windows.h>
#include <vector>
 
#include "components/resources/engine_globals/globals.h"
 
#define DEFAULT_LOG_FILENAME "debug" 
 
#ifndef BLAM
#define BLAM
#endif
 
// Warning severities
#define WSV_NONE BlamLogLevel::None          
#define WSV_ERROR BlamLogLevel::Error        
#define WSV_WARNING BlamLogLevel::Warning    
#define WSV_SEVERE BlamLogLevel::Severe      
#define WSV_CRITICAL BlamLogLevel::Severe  
 
 
#define WSV_INFO BlamLogLevel::Input
 
#define WSV_AIERR BlamLogLevel::AiError
 
// Visibility options
#define WVIS_NONE BlamLogVisibility::Vis_None           
#define WVIS_ALL BlamLogVisibility::All                 
#define WVIS_STDOUT_ONLY BlamLogVisibility::StdoutOnly  
#define WVIS_FILE_ONLY BlamLogVisibility::FileOnly      
#define WVIS_HTML_ONLY BlamLogVisibility::HTMLOnly      
#define WVIS_TXT_ONLY BlamLogVisibility::TXTOnly        
 
#define MAX_ERRORS_BEFORE_SUPRESSION 5 
 
// Helpful macros
 
#define BL_LOGEVT(m) Blam::Logger::LogEvent(m);
 
#define BL_LOGEVT_ST(m, st) Blam::Logger::LogEvent(m, st);
 
#define BL_LOGEVT_SEV(m, st, sev) Blam::Logger::LogEvent(m, st, sev);
 
#define BL_LOGEVT_RGB(m, st, sev, r, g, b) Blam::Logger::LogEvent(m, st, sev, r, g, b);
 
enum class BlamLogLevel
{
    None,      
    Warning,   
    Error,     
    Severe,    
 
    Input,
 
    AiError
};
 
enum class BlamLogVisibility
{
    Vis_None,    
    All,         
    StdoutOnly,  
    FileOnly,    
    HTMLOnly,    
    TXTOnly      
};
 
enum class BlamReportType
{
    Debug,       
    DebugFull,   
    TagDebug,    
    UIDebug,     
    ShadersDebug 
};
 
struct BlamLogMessage
{
    BlamReportType report_type = BlamReportType::Debug;  
 
    std::string timestamp;            
    std::string message;              
    BlamLogLevel severity = WSV_NONE;  
    bool show_timestamp = true;       
 
    bool override_color = false;      
    BlamColor color;                  
 
    BlamLogVisibility visibility = WVIS_ALL;    
 
    bool override_duplicate_limit = false;  
};
 
class BlamReport
{
private:
    bool log_ready = false;           
    std::string timestamped_log_path; 
 
    HRESULT WriteLineToText(std::string file_path, BlamLogMessage message);
 
    HRESULT WriteLineToHTML(std::string file_path, BlamLogMessage message);
 
public:
    std::string report_filename;
    BlamReportType report_type;
 
    BlamReport(BlamReportType type, std::string filename)
    {
        report_filename = filename;
        report_type = type;
    }
 
    void Initialize();
 
    HRESULT WriteLineToFile(BlamLogMessage message);
 
    int        LogEvent(BlamLogMessage message);
 
    void        PrintStartupHeader();
 
    bool        IsReady();
 
    void        MarkAsReady();
};
 
namespace Blam
{
    namespace Logger
    {
        namespace Internal
        {
            BLAM void    PrepareTextLog(std::string report_filename);
 
            BLAM void    PrepareHTMLLog(std::string report_filename);
 
            BLAM std::string   PrepareHTMLTemplate(std::string log_title);
 
            BLAM void    CreateReportViewerPage();
 
            BLAM void    LoadConsoleColors();
        }
 
        namespace Queue
        {
            BLAM void    Flush();
 
            BLAM void    AddMessage(BlamLogMessage message);
 
            BLAM std::vector<BlamLogMessage>*    GetQueue();
        }
 
        BLAM void        SetLoggerReady();
 
        BLAM BlamReport*     GetReport(BlamReportType type);
 
        BLAM std::string GetSeverityCSSClass(BlamLogLevel severity);
 
        BLAM void        PrepareLogger();
 
        BLAM void        LogEventAsync(std::string message);
        
        BLAM void        LogEvent(std::string message);
 
        BLAM void        LogEvent(std::string message, bool show_timestamp);
 
        BLAM void        LogEvent(std::string message, BlamReportType report_type);
 
        BLAM void        LogEvent(std::string message, bool show_timestamp, BlamLogLevel severity);
 
        BLAM void        LogEvent(std::string message, bool show_timestamp, BlamLogLevel severity, short r, short g, short b);
 
        BLAM void        LogEvent(std::string message, BlamLogLevel severity);
 
        BLAM void        LogEvent(std::string message, BlamLogLevel severity, BlamReportType report_type);
 
        BLAM void        LogEvent(std::string message, BlamLogLevel severity, BlamLogVisibility visibility);
 
        BLAM void        LogEvent(std::string message, BlamColor color);
 
        BLAM void        LogEvent(BlamLogMessage message);
 
        BLAM void        LogEventForce(std::string message, BlamLogLevel severity);
 
        BLAM void        LogEventForce(std::string message, BlamColor color);
 
        BLAM void        LogEventForce(std::string message, BlamLogLevel severity, BlamLogVisibility visibility);
 
        BLAM void        LogEventForce(std::string message, BlamLogLevel severity, BlamReportType report_type);
 
        BLAM void        LogEventForce(BlamLogMessage message);
    }
}