modify something

include/featherlog/flog_definitions.h

@@ -27,8 +27,12 @@
 
 #endif
 
-#ifndef _NODISCARD
-#define _NODISCARD [[nodiscard]]
+#ifndef NODISCARD
+# ifdef _NODISCARD
+#  define NODISCARD _NODISCARD
+# else
+#  define NODISCARD [[nodiscard]]
+# endif
 #endif
 
 #endif

include/featherlog/log_formatter.hpp

@@ -10,6 +10,6 @@ namespace flog
     public:
         virtual ~LogFormatter() = default;
 
-        _NODISCARD virtual std::string FLOG_CALL format(const LogMessage& message) = 0;
+        NODISCARD virtual std::string FLOG_CALL format(const LogMessage& message) = 0;
     };
 }

include/featherlog/log_manager.hpp

@@ -12,6 +12,7 @@
 #include <featherlog/log_outputter.hpp>
 #include <featherlog/flog_definitions.h>
 #include <featherlog/push_result.hpp>
+#include <utility>
 
 namespace flog
 {
@@ -23,26 +24,30 @@ namespace flog
         LogManager(LogManager &&) = delete;
         LogManager &operator=(LogManager &&) = delete;
 
-        _NODISCARD static std::shared_ptr<LogManager> FLOG_CALL create();
+        NODISCARD static std::shared_ptr<LogManager> FLOG_CALL create() noexcept { return {}; }
+        NODISCARD static std::shared_ptr<LogManager> FLOG_CALL create(LogMessageFlagManager flagManager);
 
         ~LogManager();
 
-        _NODISCARD LogLevel FLOG_CALL get_min_log_level() const noexcept;
+        NODISCARD LogLevel FLOG_CALL get_min_log_level() const noexcept;
                   void     FLOG_CALL set_min_log_level(LogLevel level) noexcept;
 
-        _NODISCARD PushResult<std::unique_ptr<LogOutputter>> FLOG_CALL add_outputter(
-            std::unique_ptr<LogOutputter> outputter);
-
-        _NODISCARD bool FLOG_CALL contains_outputter(std::string_view name) const;
+        NODISCARD PushResult<std::unique_ptr<LogOutputter>> FLOG_CALL
+            add_outputter(std::unique_ptr<LogOutputter> outputter);
+        NODISCARD bool FLOG_CALL contains_outputter(std::string_view name) const;
         std::optional<std::unique_ptr<LogOutputter>> FLOG_CALL try_delete_outputter(std::string_view name);
 
-        _NODISCARD std::shared_ptr<Logger> FLOG_CALL get_logger(const std::string &name);
+        NODISCARD std::shared_ptr<Logger> FLOG_CALL get_logger(const std::string &name);
 
         size_t FLOG_CALL clean_unused_loggers();
 
     private:
         LogManager() noexcept = default;
 
+        explicit LogManager(LogMessageFlagManager flagManager) noexcept :
+            m_logMessageFlagManager(std::move(flagManager))
+        {  }
+
         void FLOG_CALL write_log(const LogMessage &message) const;
 
         std::atomic<LogLevel> m_minLogLevel{LogLevel::DEBUG};
@@ -52,5 +57,8 @@ namespace flog
 
         mutable std::mutex m_loggersMutex;
         std::unordered_map<std::string, std::shared_ptr<Logger>> m_loggers;
+
+        mutable std::shared_mutex m_logMessageFlagManagerMutex;
+        LogMessageFlagManager m_logMessageFlagManager;
     };
 }

include/featherlog/log_message_flag.hpp

@@ -5,27 +5,36 @@
 
 namespace flog
 {
-    typedef uint32_t MessageFlag;
+    typedef uint32_t LogMessageFlag;
+    typedef LogMessageFlag MessageFlag;
 
-    class MessageFlagManager
+    typedef class LogMessageFlagManager
     {
     public:
-        MessageFlagManager() noexcept = default;
-        ~MessageFlagManager() = default;
+        static constexpr MessageFlag ADD_FAILED = 0;
 
-        MessageFlagManager(const MessageFlagManager&) noexcept = default;
-        MessageFlagManager& operator=(const MessageFlagManager&) noexcept = default;
-        MessageFlagManager(MessageFlagManager&&) noexcept = default;
-        MessageFlagManager& operator=(MessageFlagManager&&) noexcept = default;
+        static constexpr size_t FLAG_ARRAY_SIZE = std::numeric_limits<MessageFlag>::digits;
 
-        _NODISCARD bool isFull() const noexcept { return flagCount >= std::numeric_limits<MessageFlag>::digits; }
-        _NODISCARD bool pushable() const noexcept { return !isFull(); }
-        _NODISCARD bool isEmpty() const noexcept { return flagCount == 0; }
+        LogMessageFlagManager() noexcept = default;
+        ~LogMessageFlagManager() = default;
 
-        _NODISCARD bool contains(std::string_view name) const noexcept;
+        LogMessageFlagManager(const LogMessageFlagManager&) noexcept = default;
+        LogMessageFlagManager& operator=(const LogMessageFlagManager&) noexcept = default;
+        LogMessageFlagManager(LogMessageFlagManager&&) noexcept = default;
+        LogMessageFlagManager& operator=(LogMessageFlagManager&&) noexcept = default;
+
+        NODISCARD bool isFull()   const noexcept { return flagCount >= FLAG_ARRAY_SIZE; }
+        NODISCARD bool pushable() const noexcept { return !isFull();                    }
+        NODISCARD bool isEmpty()  const noexcept { return flagCount == 0;               }
+        NODISCARD bool empty()    const noexcept { return isEmpty();                    }
+
+        NODISCARD bool contains(std::string_view name) const noexcept;
+
+        NODISCARD MessageFlag addFlag (std::string_view name);
+        NODISCARD MessageFlag findFlag(std::string_view name) const;
 
     private:
-        std::array<std::string, std::numeric_limits<MessageFlag>::digits> m_flagMap{};
+        std::array<std::string, FLAG_ARRAY_SIZE> m_flagMap{};
         size_t flagCount { 0 };
-    };
+    } MessageFlagManager;
 }

include/featherlog/log_outputter.hpp

@@ -6,19 +6,21 @@
 #include <featherlog/log_message.hpp>
 #include <featherlog/flog_definitions.h>
 
-namespace flog {
-    class FLOG_API LogOutputter {
+namespace flog
+{
+    class FLOG_API LogOutputter
+    {
     public:
-        explicit LogOutputter(std::string name, std::unique_ptr<LogFormatter> formatter) noexcept
+        LogOutputter(std::string name, std::unique_ptr<LogFormatter> formatter) noexcept
             : m_name(std::move(name)), m_logFormatter(std::move(formatter))
         {  }
 
         virtual ~LogOutputter() = default;
 
-        _NODISCARD std::string FLOG_CALL getName() const noexcept { return m_name; }
+        NODISCARD std::string FLOG_CALL getName() const noexcept { return m_name; }
 
         std::unique_ptr<LogFormatter> FLOG_CALL set_formatter(const std::unique_ptr<LogFormatter> &formatter);
-        _NODISCARD const std::unique_ptr<LogFormatter> & FLOG_CALL get_formatter() const;
+        NODISCARD const std::unique_ptr<LogFormatter> & FLOG_CALL get_formatter() const;
 
         virtual void FLOG_CALL write_log(const LogMessage &message) = 0;
 

include/featherlog/logger.hpp

@@ -15,6 +15,11 @@ namespace flog
         friend class LogManager;
 
     public:
+        Logger(const Logger&) = delete;
+        Logger operator=(const Logger&) = delete;
+        Logger(const Logger&&) = delete;
+        Logger operator=(const Logger&&) = delete;
+
         ~Logger() = default;
 
         template<typename... Args>

include/featherlog/push_result.hpp

@@ -9,14 +9,14 @@ namespace flog
     class PushResult
     {
     public:
-        _NODISCARD static PushResult success() noexcept { return PushResult(); }
-        _NODISCARD static PushResult failWithValue(T value) noexcept
+        NODISCARD static PushResult success() noexcept { return PushResult(); }
+        NODISCARD static PushResult failWithValue(T value) noexcept
         {
             return PushResult(std::move(std::optional<T>(std::move(value))));
         }
 
-        _NODISCARD bool isSuccessful() const noexcept { return !m_value.has_value(); }
-        _NODISCARD bool isFail() const noexcept { return m_value.has_value(); }
+        NODISCARD bool isSuccessful() const noexcept { return !m_value.has_value(); }
+        NODISCARD bool isFail() const noexcept { return m_value.has_value(); }
 
         void getValueIfFail(const std::function<void(const T& value)> func) const
         {
@@ -25,7 +25,7 @@ namespace flog
             }
         }
 
-        _NODISCARD T getValue() const { return m_value.value(); }
+        NODISCARD T getValue() const { return m_value.value(); }
 
         PushResult(const PushResult &other) noexcept { m_value = other.m_value; }
 

src/log_manager.cpp

@@ -1,13 +1,10 @@
-#include <ranges>
 #include <featherlog/log_manager.hpp>
 #include <featherlog/push_result.hpp>
 
 namespace flog
 {
-    std::shared_ptr<LogManager> LogManager::create()
-    {
-        // ReSharper disable once CppDFAMemoryLeak
-        return std::shared_ptr<LogManager>(new LogManager());
+    std::shared_ptr<LogManager> LogManager::create(MessageFlagManager flagManager) {
+        return std::shared_ptr<LogManager>(new LogManager(std::move(flagManager)));
     }
 
     LogManager::~LogManager()

src/log_message_flag.cpp

@@ -0,0 +1 @@
+#include <featherlog/log_message_flag.hpp>