.

src/featherlog/log_manager.cpp

@@ -0,0 +1,103 @@
+#include "log_manager.hpp"
+
+namespace flog
+{
+
+
+    inline std::shared_ptr<LogManager> LogManager::create()
+    {
+        // ReSharper disable once CppDFAMemoryLeak
+        return std::shared_ptr<LogManager>(new LogManager());
+    }
+
+    inline LogManager::~LogManager()
+    {
+        {
+            std::lock_guard lock(m_loggersMutex);
+            m_loggers.clear();
+        }
+        {
+            std::lock_guard lock(m_logOutputtersMutex);
+            m_logOutputters.clear();
+        }
+    }
+
+    inline LogLevel LogManager::get_min_log_level() const noexcept
+    {
+        return m_minLogLevel.load(std::memory_order_relaxed);
+    }
+
+    inline void LogManager::set_min_log_level(const LogLevel level) noexcept
+    {
+        m_minLogLevel.store(level, std::memory_order_relaxed);
+    }
+
+    inline void LogManager::add_outputter(std::unique_ptr<LogOutputter> outputter)
+    {
+        std::lock_guard lock(m_logOutputtersMutex);
+        m_logOutputters.push_back(std::move(outputter));
+    }
+
+    inline std::shared_ptr<Logger> LogManager::get_logger(const std::string& name)
+    {
+        std::lock_guard lock(m_loggersMutex);
+        if (const auto it = m_loggers.find(name); it != m_loggers.end())
+        {
+            return it->second;
+        }
+
+        const auto logger = std::shared_ptr<Logger>(new Logger(name, weak_from_this()));
+        m_loggers.emplace(name, logger);
+        return logger;
+    }
+
+    inline size_t LogManager::clean_unused_loggers()
+    {
+        std::lock_guard lock(m_loggersMutex);
+        size_t count = 0;
+        for (auto it = m_loggers.begin(); it != m_loggers.end();)
+        {
+            if (it->second.use_count() == 1)
+            {
+                it = m_loggers.erase(it);
+                count += 1;
+            }
+            else
+            {
+                ++it;
+            }
+        }
+        return count;
+    }
+
+    inline void LogManager::print_log(const LogMessage& message) const
+    {
+        std::shared_lock lock(m_logOutputtersMutex);
+        for (auto& outputter : m_logOutputters)
+        {
+            outputter->write(message);
+        }
+    }
+
+    inline LoggerCallback::LoggerCallback(const std::weak_ptr<LogManager>& logManager) noexcept : m_logManager(
+        logManager)
+    {
+    }
+
+    inline void LoggerCallback::print_log(const LogMessage& message) const
+    {
+        if (const auto mgr = m_logManager.lock())
+        {
+            mgr->print_log(message);
+        }
+    }
+
+    inline LogLevel LoggerCallback::get_min_log_level() const noexcept
+    {
+        if (const auto mgr = m_logManager.lock())
+        {
+            return mgr->get_min_log_level();
+        }
+        return LogLevel::OFF;
+    }
+}