ILogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_ILOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_ILOGGER_HPP_INCLUDED
 
 
 
#include <cstddef>
#include <string>
#include <vector>
 
namespace logit {
 
    struct LogClearOptions {
        bool include_persistent_records = true; 
        bool include_payloads = true;           
        bool include_sessions = false;          
    };
 
    enum class LogClearStatus {
        Cleared,
        Unsupported,
        Failed
    };
 
    struct LogClearResult {
        bool ok = false;                  
        LogClearStatus status = LogClearStatus::Failed; 
        std::size_t cleared_records = 0;  
        std::string message;              
    };
 
 
    class ILogger {
    public:
        virtual ~ILogger() = default;
 
        virtual void log(const LogRecord& record, const std::string& message) = 0;
 
        virtual std::string get_string_param(const LoggerParam& param) const = 0;
 
        virtual int64_t get_int_param(const LoggerParam& param) const = 0;
 
        virtual double get_float_param(const LoggerParam& param) const = 0;
 
        virtual void set_log_level(LogLevel level) = 0;
 
        virtual LogLevel get_log_level() const = 0;
 
        virtual std::vector<std::string> get_buffered_strings() const {
            return std::vector<std::string>();
        }
 
        virtual std::vector<BufferedLogEntry> get_buffered_entries() const {
            return std::vector<BufferedLogEntry>();
        }
 
        virtual std::vector<LogFileInfo> list_log_files() const {
            return std::vector<LogFileInfo>();
        }
 
        virtual LogFileReadResult read_log_file(const std::string& path) const {
            LogFileReadResult result;
            result.file.path = path;
            result.ok = false;
            return result;
        }
 
        virtual std::vector<LogFileReadResult> read_log_files(const std::vector<std::string>& paths) const {
            std::vector<LogFileReadResult> results;
            results.reserve(paths.size());
            for (size_t i = 0; i < paths.size(); ++i) {
                results.push_back(read_log_file(paths[i]));
            }
            return results;
        }
 
        virtual LogClearResult clear_logs(const LogClearOptions& options = LogClearOptions()) {
            (void)options;
            LogClearResult result;
            result.ok = false;
            result.status = LogClearStatus::Unsupported;
            result.message = "unsupported";
            return result;
        }
 
        virtual void wait() = 0;
 
        virtual void shutdown() {
            wait();
        }
    }; // ILogger
 
}; // namespace logit
 
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_ILOGGER_HPP_INCLUDED