Add support for log streams (#3)

Author: maybegreat48

.gitignore

@@ -1,2 +1,3 @@
 .vscode/
-build/
+build/
+/.vs

include/AsyncLogger/Logger.hpp

@@ -16,6 +16,7 @@
 #include "LogIntermediate.hpp"
 #include "LogLevel.hpp"
 #include "LogMessage.hpp"
+#include "LogStream.hpp"
 
 namespace al
 {
@@ -37,7 +38,7 @@ namespace al
         static void FlushQueue();
 
     protected:
-        static void PushMessage(const eLogLevel level, std::chrono::system_clock::time_point&& timestamp, std::source_location&& location, std::string&& message) noexcept;
+        static void PushMessage(const eLogLevel level, std::chrono::system_clock::time_point&& timestamp, std::source_location&& location, std::string&& message, std::optional<std::shared_ptr<LogStream> const>&& stream = std::nullopt) noexcept;
 
     private:
         void CallSinks(LogMessagePtr msgPtr);
@@ -70,7 +71,17 @@ namespace al
     template<typename ...Args>
     inline void LOGF(const eLogLevel level, LogIntermediate formatString, Args&&... formatArgs)
     {
-        auto capture = LogCapture(level, std::move(formatString.Location()));
+        auto capture = LogCapture(level, std::move(formatString.Location()), std::nullopt);
+        capture << VFORMAT(formatString.FormatString(), MAKE_FORMAT_ARGS(formatArgs...));
+    }
+
+    template<typename... Args>
+    inline void LOGF(const std::shared_ptr<LogStream> stream, const eLogLevel level, LogIntermediate formatString, Args&&... formatArgs)
+    {
+        if (stream && !stream->Enabled())
+            return;
+
+        auto capture = LogCapture(level, std::move(formatString.Location()), stream);
         capture << VFORMAT(formatString.FormatString(), MAKE_FORMAT_ARGS(formatArgs...));
     }
 }

src/LogCapture.cpp

@@ -3,15 +3,16 @@
 
 namespace al
 {
-    LogCapture::LogCapture(const eLogLevel level, std::source_location&& location) :
+    LogCapture::LogCapture(const eLogLevel level, std::source_location&& location, std::optional<std::shared_ptr<LogStream> const> stream) :
         m_Level(level),
         m_Timestamp(std::chrono::system_clock::now()),
-        m_Location(location)
+        m_Location(location),
+        m_LogStream(stream)
     {}
 
     LogCapture::~LogCapture()
     {
         m_Stream << '\n';
-        Logger::PushMessage(m_Level, std::move(m_Timestamp), std::move(m_Location), std::move(m_Stream.str()));
+        Logger::PushMessage(m_Level, std::move(m_Timestamp), std::move(m_Location), std::move(m_Stream.str()), std::move(m_LogStream));
     }
 }

src/LogCapture.hpp

@@ -3,32 +3,33 @@
 #include <source_location>
 #include <sstream>
 #include "LogLevel.hpp"
+#include "LogStream.hpp"
 
 namespace al
 {
-    class Logger;
-    class LogCapture
-    {
-    public:
-        LogCapture(const eLogLevel level, std::source_location&& location);
-        ~LogCapture();
+	class Logger;
+	class LogCapture
+	{
+	public:
+		LogCapture(const eLogLevel level, std::source_location&& location, std::optional<std::shared_ptr<LogStream> const> stream);
+		~LogCapture();
 
-        template<typename T>
-        std::ostream& operator<< (const T& d);
+		template<typename T>
+		std::ostream& operator<< (const T& d);
 
-    private:
-        const eLogLevel m_Level;
-        std::chrono::system_clock::time_point m_Timestamp;
-        std::source_location m_Location;
-        std::ostringstream m_Stream;
-        
-    };
+	private:
+		const eLogLevel m_Level;
+		std::chrono::system_clock::time_point m_Timestamp;
+		std::source_location m_Location;
+		std::ostringstream m_Stream;
+		std::optional<std::shared_ptr<LogStream> const> m_LogStream;
+	};
 
-    template<typename T>
-    std::ostream& LogCapture::operator<< (const T& d)
-    {
-        m_Stream << d;
-        return m_Stream;
-    }
+	template<typename T>
+	std::ostream& LogCapture::operator<< (const T& d)
+	{
+		m_Stream << d;
+		return m_Stream;
+	}
 
 }

src/LogMessage.cpp

@@ -4,11 +4,12 @@
 
 namespace al
 {
-    LogMessage::LogMessage(const eLogLevel level, std::chrono::system_clock::time_point&& timestamp, std::source_location&& location, std::string&& message) :
+    LogMessage::LogMessage(const eLogLevel level, std::chrono::system_clock::time_point&& timestamp, std::source_location&& location, std::string&& message, std::optional<std::shared_ptr<LogStream> const> stream) :
         m_Level(level),
         m_Timestamp(timestamp),
         m_Location(location),
-        m_Message(message)
+        m_Message(message),
+        m_Stream(stream)
     {
 
     }
@@ -32,4 +33,9 @@ namespace al
     {
         return m_Timestamp;
     }
+
+    const std::optional<std::shared_ptr<LogStream> const> LogMessage::Stream() const
+    {
+        return m_Stream;
+    }
 }

src/LogMessage.hpp

@@ -2,25 +2,28 @@
 #include <source_location>
 #include <string>
 #include "LogLevel.hpp"
+#include "LogStream.hpp"
 
 namespace al
 {
     class LogMessage
     {
     public:
-        LogMessage(const eLogLevel level, std::chrono::system_clock::time_point&& timestamp, std::source_location&& location, std::string&& message);
+        LogMessage(const eLogLevel level, std::chrono::system_clock::time_point&& timestamp, std::source_location&& location, std::string&& message, std::optional<std::shared_ptr<LogStream> const> stream);
         virtual ~LogMessage() = default;
 
         const eLogLevel& Level() const;
         const std::source_location& Location() const;
         const std::string& Message() const;
         const std::chrono::system_clock::time_point& Timestamp() const;
+        const std::optional<std::shared_ptr<LogStream> const> Stream() const;
 
     private:
         const eLogLevel m_Level;
         const std::chrono::system_clock::time_point m_Timestamp;
         const std::source_location m_Location;
         const std::string m_Message;
+        const std::optional<std::shared_ptr<LogStream> const> m_Stream;
 
     };
 }

src/LogStream.cpp

@@ -0,0 +1,31 @@
+#include "LogStream.hpp"
+
+namespace al
+{
+    LogStream::LogStream(std::string name, void* userData) :
+        m_Name(name),
+        m_UserData(userData),
+        m_Enabled(true)
+    {
+    }
+
+    const std::string& LogStream::Name() const
+    {
+        return m_Name;
+    }
+
+    const void* LogStream::UserData() const
+    {
+        return m_UserData;
+    }
+
+    bool LogStream::Enabled() const
+    {
+        return m_Enabled;
+    }
+
+    void LogStream::SetEnabled(bool state)
+    {
+        m_Enabled = state;
+    }
+}

src/LogStream.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include "LogIntermediate.hpp"
+
+namespace al
+{
+    class LogStream
+    {
+    public:
+        LogStream(std::string name, void* userData = nullptr);
+        
+        const std::string& Name() const;
+        const void* UserData() const;
+        bool Enabled() const;
+
+        void SetEnabled(bool state);
+
+    private:
+        std::string m_Name;
+        void* m_UserData;
+        bool m_Enabled;
+
+    };
+}

src/Logger.cpp

@@ -6,7 +6,7 @@ namespace al
 {
     LogCapture LOG(const eLogLevel level, std::source_location location)
     {
-        return LogCapture{ level, std::move(location) };
+        return LogCapture{ level, std::move(location), std::nullopt };
     }
 
     void Logger::AddSink(LogSink sink)
@@ -32,8 +32,9 @@ namespace al
     void Logger::PushMessage(const eLogLevel level,
                              std::chrono::system_clock::time_point &&timestamp,
                              std::source_location &&location,
-                             std::string &&message) noexcept {
-        auto msgPtr = std::make_shared<LogMessage>(level, std::move(timestamp), std::move(location), std::move(message));
+                             std::string &&message, std::optional<std::shared_ptr<LogStream> const> &&stream) noexcept
+    {
+        auto msgPtr = std::make_shared<LogMessage>(level, std::move(timestamp), std::move(location), std::move(message), std::move(stream));
 
         Logger::GetInstance().QueueMessage(std::move(msgPtr));
     }