ConsoleSink.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2021 - 2021.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SL_LOG_CONSOLE_SINK_HPP
#define SL_LOG_CONSOLE_SINK_HPP
 
#pragma once
 
#include "OStreamSink.hpp"
#include "Record.hpp"
 
// rang.hpp includes windows.hpp internally, thus macros min and max will be defined. This macro prevents this.
#define NOMINMAX
#include "third_party/rang/rang.hpp"
 
#include <cassert>
#include <functional>
#include <iostream>
#include <mutex>
#include <unordered_map>
 
namespace sl::log
{
    struct ConsoleTextStyle
    {
        enum class Color
        {
            black = 0,
            red,
            green,
            yellow,
            blue,
            magenta,
            cyan,
            gray,
            standard,
 
            brightBlack,
            brightRed,
            brightGreen,
            brightYellow,
            brightBlue,
            brightMagenta,
            brightCyan,
            brightGray,
        };
 
        enum class Style
        {
            standard = 0,
            bold,
            dim,
            italic,
            underline,
            reversed = 7,
            crossed = 9
        };
 
        Style style = Style::standard;
 
        Color textColor = Color::standard;
 
        Color bgColor = Color::standard;
    };
 
    template <class T, class TRecord>
    concept ConsoleTextStylePolicyFor =
    Record<TRecord> &&
    std::is_invocable_r_v<ConsoleTextStyle, T, const TRecord&>;
 
    constexpr ConsoleTextStyle defaultConsoleTextStyle;
 
}
 
namespace sl::log::detail
{
    std::ostream& applyTextColor(std::ostream& out, ConsoleTextStyle::Color color) noexcept;
    std::ostream& applyBackgroundColor(std::ostream& out, ConsoleTextStyle::Color color) noexcept;
    std::ostream& applyStyle(std::ostream& out, ConsoleTextStyle::Style style) noexcept;
}
 
namespace sl::log
{
    inline std::ostream& operator <<(std::ostream& out, const ConsoleTextStyle& style)
    {
        detail::applyStyle(out, style.style);
        detail::applyTextColor(out, style.textColor);
        detail::applyBackgroundColor(out, style.bgColor);
        return out;
    }
 
    template <class TProjection, class TTable>
    class ConsoleTextStyleTable
    {
    public:
        using Projection_t = std::remove_cvref_t<TProjection>;
        using Table_t = std::remove_cvref_t<TTable>;
        using Key_t = typename Table_t::key_type;
 
        ConsoleTextStyleTable(TProjection projection, TTable table) :
            m_Projection{ std::move(projection) },
            m_StyleTable{ std::move(table) }
        {
        }
 
        template <Record TRecord>
        ConsoleTextStyle operator ()(const TRecord& record) const
        {
            if (auto itr = m_StyleTable.find(std::invoke(m_Projection, record)); itr != std::end(m_StyleTable))
            {
                return itr->second;
            }
            return defaultConsoleTextStyle;
        }
 
        void insert(Key_t key, ConsoleTextStyle style)
        {
            m_StyleTable.insert_or_assign(std::move(key), std::move(style));
        }
 
    private:
        Projection_t m_Projection;
        Table_t m_StyleTable;
    };
 
    template <Record TRecord,
        std::invocable<const TRecord&> TProjection,
        class TTable = std::unordered_map<
            std::remove_cvref_t<std::invoke_result_t<TProjection, const TRecord&>>,
            ConsoleTextStyle
        >>
    auto makeConsoleTextStyleTableFor(TProjection projection, TTable table)
    {
        return ConsoleTextStyleTable{ std::move(projection), std::move(table) };
    }
 
    template <Record TRecord>
    class ConsoleSink final :
        public OStreamSink<TRecord>
    {
        using Super = OStreamSink<TRecord>;
 
    public:
        using typename Super::Record_t;
        using typename Super::Formatter_t;
        using typename Super::Filter_t;
        using typename Super::FlushPolicy_t;
        using TextStylePolicy_t = std::function<ConsoleTextStyle(const Record_t&)>;
 
    protected:
        [[nodiscard]]
        static constexpr TextStylePolicy_t defaultTextStylePolicy()
        {
            return [](const Record_t&) { return defaultConsoleTextStyle; };
        }
 
    public:
        explicit ConsoleSink() :
            Super{ std::cout }
        {
        }
 
        ~ConsoleSink() noexcept = default;
 
        ConsoleSink(const ConsoleSink&) = delete;
        ConsoleSink& operator =(const ConsoleSink&) = delete;
 
        ConsoleSink(ConsoleSink&&) = delete;
        ConsoleSink& operator =(ConsoleSink&&) = delete;
 
        template <ConsoleTextStylePolicyFor<Record_t> TStylePolicy>
        void setTextStylePolicy(TStylePolicy&& policy)
        {
            std::scoped_lock lock{ m_TextStylePolicyMx };
            m_TextStylePolicy = std::forward<TStylePolicy>(policy);
        }
 
        void removeTextStylePolicy()
        {
            std::scoped_lock lock{ m_TextStylePolicyMx };
            m_TextStylePolicy = defaultTextStylePolicy();
        }
 
    private:
        std::mutex m_TextStylePolicyMx;
        TextStylePolicy_t m_TextStylePolicy{ defaultTextStylePolicy() };
 
        void beforeMessageWrite(const Record_t& record, std::string_view message) override
        {
            std::scoped_lock lock{ m_TextStylePolicyMx };
            assert(m_TextStylePolicy && "TextStylePolicy must not be empty.");
            std::cout << std::invoke(m_TextStylePolicy, record);
        }
 
        void afterMessageWrite(const Record_t& record, std::string_view message) override
        {
            std::cout << defaultConsoleTextStyle;
        }
    };
 
}
 
namespace sl::log::detail
{
    inline std::ostream& applyTextColor(std::ostream& out, ConsoleTextStyle::Color color) noexcept
    {
        using Color = ConsoleTextStyle::Color;
        if (color < Color::brightBlack)
        {
            const auto begin = static_cast<unsigned>(rang::fg::black);
            out << static_cast<rang::fg>(static_cast<unsigned>(color) + begin);
        }
        else
        {
            const auto begin = static_cast<unsigned>(rang::fgB::black);
            const auto localColor = static_cast<Color>(begin +
                                                        static_cast<unsigned>(color) -
                                                        static_cast<unsigned>(Color::brightBlack));
            out << static_cast<rang::fgB>(localColor);
        }
        return out;
    }
 
    inline std::ostream& applyBackgroundColor(std::ostream& out, ConsoleTextStyle::Color color) noexcept
    {
        using Color = ConsoleTextStyle::Color;
        if (color < Color::brightBlack)
        {
            const auto begin = static_cast<unsigned>(rang::bg::black);
            out << static_cast<rang::bg>(static_cast<unsigned>(color) + begin);
        }
        else
        {
            const auto begin = static_cast<unsigned>(rang::bgB::black);
            const auto localColor = static_cast<Color>(begin +
                                                        static_cast<unsigned>(color) -
                                                        static_cast<unsigned>(Color::brightBlack));
            out << static_cast<rang::bgB>(localColor);
        }
        return out;
    }
 
    inline std::ostream& applyStyle(std::ostream& out, ConsoleTextStyle::Style style) noexcept
    {
        const auto value = static_cast<rang::style>(style);
        out << value;
        return out;
    }
}
 
#endif