Initial Commit

Author: Yimura

.gitignore

@@ -0,0 +1,2 @@
+.vscode/
+build/

CMakeLists.txt

@@ -0,0 +1,46 @@
+cmake_minimum_required(VERSION 3.20)
+
+project(AsyncLogger LANGUAGES CXX VERSION 0.0.1 DESCRIPTION "A lightweight C++20 asyncronous logger.")
+
+set(SRC_DIR "${PROJECT_SOURCE_DIR}/src/")
+
+# check std::format support
+if(NOT USE_FMT)
+    include(CheckIncludeFileCXX)
+    check_include_file_cxx("format" CXX_FORMAT_SUPPORT)
+else()
+    set(CXX_FORMAT_SUPPORT 0)
+endif()
+
+file(GLOB_RECURSE SRC_FILES
+    "${SRC_DIR}**.cpp"
+    "${SRC_DIR}**.hpp"
+)
+
+add_library(${PROJECT_NAME} STATIC ${SRC_FILES})
+
+if(CXX_FORMAT_SUPPORT)
+    message("Using std::format for formatting, you can set USE_FMT to force fmt::format instead.")
+else()
+    message("Using fmt::format for formatting.")
+    include(FetchContent)
+
+    FetchContent_Declare(
+        fmt
+        GIT_REPOSITORY https://github.com/fmtlib/fmt.git
+        GIT_TAG 9.1.0
+        GIT_PROGRESS TRUE
+    )
+    FetchContent_MakeAvailable(fmt)
+
+    target_link_libraries(${PROJECT_NAME} fmt)
+endif()
+
+# does the -lpthread linking for us on Linux
+find_package(Threads REQUIRED)
+target_link_libraries(${PROJECT_NAME} Threads::Threads )
+
+set_target_properties(${PROJECT_NAME} PROPERTIES PUBLIC_HEADER src/Logger.hpp)
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${SRC_DIR})

src/LogCapture.cpp

@@ -0,0 +1,18 @@
+#include "LogCapture.hpp"
+#include "Logger.hpp"
+
+namespace base
+{
+    LogCapture::LogCapture(const eLogLevel level, std::source_location&& location) :
+        m_Level(level),
+        m_Location(location)
+    {
+
+    }
+
+    LogCapture::~LogCapture()
+    {
+        m_Stream << '\n';
+        Logger::PushMessage(m_Level, std::move(m_Location), std::move(m_Stream.str()));
+    }
+}

src/LogCapture.hpp

@@ -0,0 +1,32 @@
+#pragma once
+#include <source_location>
+#include <sstream>
+#include "LogLevel.hpp"
+
+namespace base
+{
+    class Logger;
+    class LogCapture
+    {
+    public:
+        LogCapture(const eLogLevel level, std::source_location&& location);
+        ~LogCapture();
+
+        template<typename T>
+        std::ostream& operator<< (const T& d);
+
+    private:
+        const eLogLevel m_Level;
+        std::source_location m_Location;
+        std::ostringstream m_Stream;
+        
+    };
+
+    template<typename T>
+    std::ostream& LogCapture::operator<< (const T& d)
+    {
+        m_Stream << d;
+        return m_Stream;
+    }
+
+}

src/LogIntermediate.cpp

@@ -0,0 +1,28 @@
+#include "LogIntermediate.hpp"
+
+namespace base
+{
+    LogIntermediate::LogIntermediate(const std::string_view formatString, const std::source_location location) :
+        m_FormatString(formatString),
+        m_Location(location)
+    {
+        
+    }
+
+    LogIntermediate::LogIntermediate(const char* formatString, const std::source_location location) :
+        m_FormatString(formatString),
+        m_Location(location)
+    {
+
+    }
+
+    const std::string_view LogIntermediate::FormatString() const
+    {
+        return m_FormatString;
+    }
+
+    std::source_location&& LogIntermediate::Location()
+    {
+        return std::move(m_Location);
+    }
+}

src/LogIntermediate.hpp

@@ -0,0 +1,22 @@
+#pragma once
+#include <source_location>
+#include <string_view>
+
+namespace base
+{
+    class LogIntermediate
+    {
+    public:
+        LogIntermediate(const std::string_view formatString, const std::source_location location = std::source_location::current());
+        LogIntermediate(const char* formatString, const std::source_location location = std::source_location::current());
+        virtual ~LogIntermediate() = default;
+
+        const std::string_view FormatString() const;
+        std::source_location&& Location();
+
+    private:
+        const std::string_view m_FormatString;
+        std::source_location m_Location;
+
+    };
+}

src/LogLevel.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace base
+{
+    enum eLogLevel
+    {
+        DEBUG,
+        INFO,
+        WARNING,
+        ERROR
+    };
+}

src/LogMessage.cpp

@@ -0,0 +1,29 @@
+#include "LogMessage.hpp"
+#include "LogLevel.hpp"
+
+namespace base
+{
+    LogMessage::LogMessage(const eLogLevel level, std::source_location&& location, std::string&& message) :
+        m_Level(level),
+        m_Location(location),
+        m_Message(message)
+    {
+        
+    }
+
+    const eLogLevel& LogMessage::Level() const
+    {
+        return m_Level;
+    }
+
+    const std::source_location& LogMessage::Location() const
+    {
+        return m_Location;
+    }
+
+    const std::string& LogMessage::Message() const
+    {
+        return m_Message;
+    }
+
+}

src/LogMessage.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include <source_location>
+#include <string>
+#include "LogLevel.hpp"
+
+namespace base
+{
+    class LogMessage
+    {
+    public:
+        LogMessage(const eLogLevel level, std::source_location&& location, std::string&& message);
+        virtual ~LogMessage() = default;
+
+        const eLogLevel& Level() const;
+        const std::source_location& Location() const;
+        const std::string& Message() const;
+
+    private:
+        const eLogLevel m_Level;
+        const std::source_location m_Location;
+        const std::string m_Message;
+
+    };
+}

src/Logger.cpp

@@ -0,0 +1,72 @@
+#include "Logger.hpp"
+#include "LogCapture.hpp"
+#include "LogMessage.hpp"
+
+namespace base
+{
+    LogCapture LOG(const eLogLevel level, std::source_location location)
+    {
+        return LogCapture{ level, std::move(location) };
+    }
+
+    void Logger::AddSink(LogSink sink)
+    {
+        Logger::GetInstance().m_Sinks.push_back(sink);
+    }
+
+    void Logger::Destroy()
+    {
+        Logger::GetInstance().DestroyImpl();
+    }
+
+    void Logger::Init()
+    {
+        Logger::GetInstance().InitImpl();
+    }
+
+    void Logger::PushMessage(const eLogLevel level, std::source_location&& location, std::string&& message) noexcept
+    {
+        auto msgPtr = std::make_shared<LogMessage>(level, std::move(location), std::move(message));
+
+        Logger::GetInstance().QueueMessage(std::move(msgPtr));
+    }
+
+    void Logger::CallSinks(LogMessagePtr msgPtr)
+    {
+        for (const auto &sink : m_Sinks)
+        {
+            sink(msgPtr);
+        }
+    }
+
+    void Logger::DestroyImpl()
+    {
+        m_Queue.push([this]
+        {
+            m_Running = false;
+        });
+        m_LogWorker.join();
+    }
+
+    void Logger::InitImpl()
+    {
+        m_Running = true;
+        m_LogWorker = std::thread([this]
+        {
+            while (m_Running)
+            {
+                std::function<void()> func;
+                m_Queue.wait_and_pop(func);
+                func();
+            }
+        });
+    }
+
+    void Logger::QueueMessage(LogMessagePtr msgPtr)
+    {
+        m_Queue.push([this, msgPtr = std::move(msgPtr)]
+        {
+            CallSinks(msgPtr);
+        });
+    }
+}