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 LogSeverity::None          
#define WSV_INFO LogSeverity::Info          
#define WSV_ERROR LogSeverity::Error        
#define WSV_WARNING LogSeverity::Warning    
#define WSV_SEVERE LogSeverity::Severe      
#define WSV_CRITICAL LogSeverity::Critical  
#define WSV_AIERR LogSeverity::AiError      
 
//visibility options
#define WVIS_NONE LogVisibility::Vis_None           
#define WVIS_ALL LogVisibility::All                 
#define WVIS_STDOUT_ONLY LogVisibility::StdoutOnly  
#define WVIS_FILE_ONLY LogVisibility::FileOnly      
#define WVIS_HTML_ONLY LogVisibility::HTMLOnly      
#define WVIS_TXT_ONLY LogVisibility::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 LogSeverity
{
    None,      
    Info,      
    Error,     
    Warning,   
    Severe,    
    Critical,  
    AiError    
};
 
enum LogVisibility
{
    Vis_None,    
    All,         
    StdoutOnly,  
    FileOnly,    
    HTMLOnly,    
    TXTOnly      
};
 
enum ReportType
{
    Debug,      
    DebugFull,  
    TagDebug,   
    UIDebug,    
};
 
namespace Blam
{
    namespace Logger
    {
        struct LogMessage
        {
            ReportType report_type = ReportType::Debug;  
 
            std::string timestamp;            
            std::string message;              
            LogSeverity severity = WSV_NONE;  
            bool show_timestamp = true;       
 
            bool override_color = false;      
            BlamColor color;                  
 
            LogVisibility visibility = WVIS_ALL;    
 
            bool override_duplicate_limit = false;  
        };
 
        class Report
        {
        private:
            bool log_ready = false;           
            std::string timestamped_log_path; 
 
            HRESULT WriteLineToText(std::string file_path, Blam::Logger::LogMessage message);
 
            HRESULT WriteLineToHTML(std::string file_path, Blam::Logger::LogMessage message);
 
        public:
            std::string report_filename;
            ReportType report_type;
 
            Report(ReportType type, std::string filename)
            {
                report_filename = filename;
                report_type = type;
            }
 
            void Initialize();
 
            HRESULT WriteLineToFile(Blam::Logger::LogMessage message);
 
            int        LogEvent(Blam::Logger::LogMessage message);
 
            void        PrintStartupHeader();
 
            bool        IsReady();
 
            void        MarkAsReady();
        };
 
        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(Blam::Logger::LogMessage message);
 
            BLAM std::vector<Blam::Logger::LogMessage>*    GetQueue();
        }
 
        BLAM void        SetLoggerReady();
 
        BLAM Report*     GetReport(ReportType type);
 
        BLAM std::string GetSeverityCSSClass(LogSeverity 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, ReportType report_type);
 
        BLAM void        LogEvent(std::string message, bool show_timestamp, LogSeverity severity);
 
        BLAM void        LogEvent(std::string message, bool show_timestamp, LogSeverity severity, short r, short g, short b);
 
        BLAM void        LogEvent(std::string message, LogSeverity severity);
 
        BLAM void        LogEvent(std::string message, LogSeverity severity, ReportType report_type);
 
        BLAM void        LogEvent(std::string message, LogSeverity severity, LogVisibility visibility);
 
        BLAM void        LogEvent(std::string message, BlamColor color);
 
        BLAM void        LogEvent(Blam::Logger::LogMessage message);
 
        BLAM void        LogEventForce(std::string message, LogSeverity severity);
 
        BLAM void        LogEventForce(std::string message, BlamColor color);
 
        BLAM void        LogEventForce(std::string message, LogSeverity severity, LogVisibility visibility);
 
        BLAM void        LogEventForce(std::string message, LogSeverity severity, ReportType report_type);
 
        BLAM void        LogEventForce(Blam::Logger::LogMessage message);
    }
}