Log.hpp

#pragma once
 
#include <fmt/ostream.h>
 
#include <array>
#include <fstream>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
namespace PixelBullet::Log
{
    enum class Level
    {
        Trace = 0,
        Info,
        Warn,
        Error,
        Critical,
        Count
    };
 
    inline constexpr std::array<const char*, static_cast<size_t>(Level::Count)> LEVEL_STRINGS = { "TRACE:", "INFO:",
                                                                                                  "WARN:", "ERROR:",
                                                                                                  "CRITICAL:" };
 
    inline constexpr const char* ToString(Level level)
    {
        return LEVEL_STRINGS[static_cast<size_t>(level)];
    }
 
    class Sink
    {
    public:
        virtual ~Sink() = default;
 
        virtual void Log(const std::string& channelName, const std::string& message, Level level) = 0;
 
        void SetMinLevel(Level level)
        {
            m_MinLevel = level;
        }
        Level GetMinLevel() const
        {
            return m_MinLevel;
        }
 
    protected:
        Level m_MinLevel = Level::Trace;
        std::mutex m_Mutex;
    };
 
    class ConsoleSink : public Sink
    {
    public:
        explicit ConsoleSink(Level minLevel = Level::Trace)
        {
            m_MinLevel = minLevel;
        }
 
        void Log(const std::string& channelName, const std::string& message, Level level) override;
    };
 
    class FileSink : public Sink
    {
    public:
        explicit FileSink(const std::string& filename, Level minLevel = Level::Trace);
        ~FileSink();
 
        void Log(const std::string& channelName, const std::string& message, Level level) override;
 
    private:
        std::ofstream m_FileStream;
    };
 
    class Channel final
    {
    public:
        static void Init();
 
        static std::shared_ptr<Channel>& Core();
        static std::shared_ptr<Channel>& Client();
 
        template <typename... Args>
        void Log(Level level, fmt::format_string<Args...> fmtStr, Args&&... args)
        {
            std::string message = fmt::format(fmtStr, std::forward<Args>(args)...);
 
            for (auto& sink : m_Sinks)
            {
                sink->Log(m_Name, message, level);
            }
        }
 
        Channel(const Channel&) = delete;
        Channel& operator=(const Channel&) = delete;
 
    private:
        explicit Channel(std::string name);
 
        void AddSink(const std::shared_ptr<Sink>& sink);
 
        std::string m_Name;
        std::vector<std::shared_ptr<Sink>> m_Sinks;
 
        static std::shared_ptr<Channel> s_CoreChannel;
        static std::shared_ptr<Channel> s_ClientChannel;
    };
 
    template <typename... Args>
    void Trace(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        Channel::Core()->Log(Level::Trace, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Info(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        Channel::Core()->Log(Level::Info, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Warn(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        Channel::Core()->Log(Level::Warn, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Error(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        Channel::Core()->Log(Level::Error, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Critical(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        Channel::Core()->Log(Level::Critical, fmtStr, std::forward<Args>(args)...);
    }
 
} // namespace PixelBullet::Log
 
namespace Log
{
    template <typename... Args>
    void Trace(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        PixelBullet::Log::Channel::Client()->Log(PixelBullet::Log::Level::Trace, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Info(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        PixelBullet::Log::Channel::Client()->Log(PixelBullet::Log::Level::Info, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Warn(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        PixelBullet::Log::Channel::Client()->Log(PixelBullet::Log::Level::Warn, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Error(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        PixelBullet::Log::Channel::Client()->Log(PixelBullet::Log::Level::Error, fmtStr, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Critical(fmt::format_string<Args...> fmtStr, Args&&... args)
    {
        PixelBullet::Log::Channel::Client()->Log(PixelBullet::Log::Level::Critical, fmtStr,
                                                 std::forward<Args>(args)...);
    }
} // namespace Log