logger.h

Go to the documentation of this file.

#pragma once
 
#include "components/resources/engine_globals/globals.h"
 
#include <Windows.h>
#include <vector>
 
#define DEFAULT_LOG_FILENAME "debug" 
 
#ifndef BLAM
#define BLAM
#endif
 
//warning severities
#define WSV_NONE Blam::Logger::LogSeverity::None          
#define WSV_INFO Blam::Logger::LogSeverity::Info          
#define WSV_ERROR Blam::Logger::LogSeverity::Error        
#define WSV_WARNING Blam::Logger::LogSeverity::Warning    
#define WSV_SEVERE Blam::Logger::LogSeverity::Severe      
#define WSV_CRITICAL Blam::Logger::LogSeverity::Critical  
#define WSV_AIERR Blam::Logger::LogSeverity::AiError      
 
//visibility options
#define WVIS_NONE Blam::Logger::LogVisibility::Vis_None           
#define WVIS_ALL Blam::Logger::LogVisibility::All                 
#define WVIS_STDOUT_ONLY Blam::Logger::LogVisibility::StdoutOnly  
#define WVIS_FILE_ONLY Blam::Logger::LogVisibility::FileOnly      
#define WVIS_HTML_ONLY Blam::Logger::LogVisibility::HTMLOnly      
#define WVIS_TXT_ONLY Blam::Logger::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); 
 
namespace Blam
{
    namespace Logger
    {
        enum LogSeverity
        {
            None,      
            Info,      
            Error,     
            Warning,   
            Severe,    
            Critical,  
            AiError    
        };
 
        enum LogVisibility
        {
            Vis_None,    
            All,         
            StdoutOnly,  
            FileOnly,    
            HTMLOnly,    
            TXTOnly      
        };
 
        enum ReportType
        {
            Debug,      
            DebugFull,  
            TagDebug,   
            UIDebug,    
        };
 
        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, bool show_timestamp, Blam::Logger::LogSeverity severity);
 
        BLAM void        LogEvent(std::string message, bool show_timestamp, Blam::Logger::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);
    }
}