modify something

src/log_manager.cpp

@@ -2,13 +2,16 @@
 #include <featherlog/log_manager.hpp>
 #include <featherlog/push_result.hpp>
 
-namespace flog {
-    std::shared_ptr<LogManager> LogManager::create() {
+namespace flog
+{
+    std::shared_ptr<LogManager> LogManager::create()
+    {
         // ReSharper disable once CppDFAMemoryLeak
         return std::shared_ptr<LogManager>(new LogManager());
     }
 
-    LogManager::~LogManager() {
+    LogManager::~LogManager()
+    {
         {
             std::lock_guard lock(m_loggersMutex);
             m_loggers.clear();
@@ -19,31 +22,37 @@ namespace flog {
         }
     }
 
-    LogLevel LogManager::get_min_log_level() const noexcept {
+    LogLevel LogManager::get_min_log_level() const noexcept
+    {
         return m_minLogLevel.load(std::memory_order_relaxed);
     }
 
-    void LogManager::set_min_log_level(const LogLevel level) noexcept {
+    void LogManager::set_min_log_level(const LogLevel level) noexcept
+    {
         m_minLogLevel.store(level, std::memory_order_relaxed);
     }
 
     PushResult<std::unique_ptr<LogOutputter>> LogManager::add_outputter(std::unique_ptr<LogOutputter> outputter)
     {
         std::lock_guard lock(m_logOutputtersMutex);
-        if (m_logOutputters.contains(outputter->getName())) {
+        if (m_logOutputters.contains(outputter->getName()))
+        {
             return PushResult<std::unique_ptr<LogOutputter>>::failWithValue(std::move(outputter));
         }
         m_logOutputters.emplace(outputter->getName(), std::move(outputter));
         return PushResult<std::unique_ptr<LogOutputter>>::success();
     }
 
-    bool LogManager::contains_outputter(const std::string_view name) const noexcept {
+    bool LogManager::contains_outputter(const std::string_view name) const noexcept
+    {
         std::shared_lock lock(m_logOutputtersMutex);
         return m_logOutputters.contains(name.data());
     }
 
-    std::optional<std::unique_ptr<LogOutputter>> LogManager::try_delete_outputter(const std::string_view name) noexcept {
-        if (contains_outputter(name)) {
+    std::optional<std::unique_ptr<LogOutputter>> LogManager::try_delete_outputter(const std::string_view name) noexcept
+    {
+        if (contains_outputter(name))
+        {
             std::lock_guard lock(m_logOutputtersMutex);
             const auto it = m_logOutputters.find(name.data());
             std::optional outputter = std::move(it->second);
@@ -53,9 +62,11 @@ namespace flog {
         return std::nullopt;
     }
 
-    std::shared_ptr<Logger> LogManager::get_logger(const std::string &name) {
+    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()) {
+        if (const auto it = m_loggers.find(name); it != m_loggers.end())
+        {
             return it->second;
         }
 
@@ -64,23 +75,30 @@ namespace flog {
         return logger;
     }
 
-    size_t LogManager::clean_unused_loggers() {
+    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) {
+        for (auto it = m_loggers.begin(); it != m_loggers.end();)
+        {
+            if (it->second.use_count() == 1)
+            {
                 it = m_loggers.erase(it);
                 count += 1;
-            } else {
+            }
+            else
+            {
                 ++it;
             }
         }
         return count;
     }
 
-    void LogManager::write_log(const LogMessage &message) const {
+    void LogManager::write_log(const LogMessage &message) const
+    {
         std::shared_lock lock(m_logOutputtersMutex);
-        for (const std::unique_ptr<LogOutputter> &outputter: m_logOutputters | std::views::values) {
+        for (const std::unique_ptr<LogOutputter> &outputter: m_logOutputters | std::views::values)
+        {
             outputter->write_log(message);
         }
     }