Logger.hpp

Go to the documentation of this file.

#pragma once
#ifndef _LOGIT_LOGGER_HPP_INCLUDED
#define _LOGIT_LOGGER_HPP_INCLUDED
 
#include "Logger/ILogger.hpp"
#include "Formatter/ILogFormatter.hpp"
#include <memory>
#include <mutex>
#include <sstream>
 
namespace logit {
 
    class Logger {
    public:
 
        static Logger& get_instance() {
            static Logger instance;
            return instance;
        }
 
        void wait() {
            for (const auto& strategy : m_loggers) {
                strategy.logger->wait();
            }
        }
 
        void add_logger(
                std::unique_ptr<ILogger> logger,
                std::unique_ptr<ILogFormatter> formatter,
                bool single_mode = false) {
            std::lock_guard<std::mutex> lock(m_mutex);
            m_loggers.push_back(
                LoggerStrategy{std::move(logger),
                std::move(formatter),
                single_mode,
                true // Loggers are enabled by default
            });
        }
 
        void set_logger_enabled(int logger_index, bool enabled) {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                m_loggers[logger_index].enabled = enabled;
            }
        }
 
        bool is_logger_enabled(int logger_index) const {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                return m_loggers[logger_index].enabled;
            }
            return false;
        }
 
        void set_logger_single_mode(int logger_index, bool single_mode) {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                m_loggers[logger_index].single_mode = single_mode;
            }
        }
 
        bool is_logger_single_mode(int logger_index) const {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                return m_loggers[logger_index].single_mode;
            }
            return false;
        }
 
        void log(const LogRecord& record) {
            std::lock_guard<std::mutex> lock(m_mutex);
            // Log to the specific logger if the index is valid
            if (record.logger_index >= 0 && record.logger_index < static_cast<int>(m_loggers.size())) {
                const auto& strategy = m_loggers[record.logger_index];
                strategy.logger->log(record, strategy.formatter->format(record));
                return;
            }
            for (const auto& strategy : m_loggers) {
                if (strategy.single_mode) continue;
                strategy.logger->log(record, strategy.formatter->format(record));
            }
        }
 
        std::string get_string_param(int logger_index, const LoggerParam& param) const {
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                const auto& strategy = m_loggers[logger_index];
                return strategy.logger->get_string_param(param);
            }
            return std::string();
        }
 
        int64_t get_int_param(int logger_index, const LoggerParam& param) const {
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                const auto& strategy = m_loggers[logger_index];
                return strategy.logger->get_int_param(param);
            }
            return 0;
        }
 
        double get_float_param(int logger_index, const LoggerParam& param) const {
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                const auto& strategy = m_loggers[logger_index];
                return strategy.logger->get_float_param(param);
            }
            return 0.0;
        }
 
        template <typename... Ts>
        auto log_and_return(const LogRecord& record, Ts&&... args) -> decltype(std::forward_as_tuple(std::forward<Ts>(args)...)) {
            this->print(record, args...);
            return std::forward_as_tuple(std::forward<Ts>(args)...);
        }
 
        template <typename T>
        auto log_and_return(const LogRecord& record, T&& arg) -> decltype(arg) {
            this->print(record, arg);
            return std::forward<decltype(arg)>(arg);
        }
 
        auto log_and_return(const LogRecord& record) -> std::tuple<> {
            this->print(record);
            return {};
        }
 
    private:
 
        struct LoggerStrategy {
            std::unique_ptr<ILogger> logger;            
            std::unique_ptr<ILogFormatter> formatter;   
            bool single_mode;                           
            bool enabled;                               
        };
 
        std::vector<LoggerStrategy> m_loggers;  
        mutable std::mutex m_mutex;             
 
        template <typename... Ts>
        void print(const LogRecord& record, Ts const&... args) {
            if (sizeof...(Ts) == 0) {
                log(record);
                return;
            }
            LogRecord mutable_record = record;
            auto var_names = split_arguments(mutable_record.arg_names);
            mutable_record.args_array = args_to_array(var_names.begin(), args...);
            log(mutable_record);
        }
 
        Logger() = default;
 
        ~Logger() {
            wait();
        }
 
        // Deleting copy and move constructors and assignment operators to enforce singleton.
        Logger(const Logger&) = delete;
        Logger& operator=(const Logger&) = delete;
        Logger(Logger&&) = delete;
        Logger& operator=(Logger&&) = delete;
    };
 
}; // namespace logit
 
#endif // _LOGIT_LOGGER_HPP_INCLUDED