LoggerManager.hh

#ifndef GRAIL_LOGGER_MANAGER_H
#define GRAIL_LOGGER_MANAGER_H
 
#include <atomic>
#include <condition_variable>
#include <map>
#include <memory>
#include <mutex>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
 
#include "Sink.hh"
 
namespace logger_hidden_namespace
{
    std::string grail_preprocess_file_path(const char* _file);
}
 
#define GRAIL_LOG(name, severity, message) grail::LoggerManager::GetInstance().Log((name),  (severity), (message), logger_hidden_namespace::grail_preprocess_file_path(__FILE__), __LINE__)
 
namespace grail
{
    namespace consts
    {
        constexpr const char DEFAULT_GRAIL_LOG_GROUP[] = "grail";
    }
 
    enum class Severity
    {
        TRACE = 0,
        DEBUG = 1,
        INFO = 2,
        WARNING = 3,
        ERRORS = 4,
        CRITICAL = 5,
    };
 
    class LoggerManager final
    {
    public:
        LoggerManager(const LoggerManager&) = delete;
        LoggerManager(LoggerManager&&) = delete;
        ~LoggerManager();
        LoggerManager& operator=(const LoggerManager&) = delete;
        LoggerManager& operator=(LoggerManager&&) = delete;
        static LoggerManager& GetInstance();
        void CreateLogger(const std::string& loggerName);
        void AddSinkToLogger(const std::string& loggerName, std::shared_ptr<Sink> sink);
        void Log(const std::string& loggerName,
                 const Severity& severity,
                 const std::string& message,
                 const std::string& file,
                 int line) const;
 
        void ClearLoggers();
 
    private:
        LoggerManager();
        std::string SeverityMessage(Severity severity) const;
        std::map<std::string, std::vector<std::shared_ptr<Sink>>> loggers{};
 
        mutable std::mutex loggerMutex{};
    };
}
#endif  //GRAIL_LOGGER_MANAGER_H