BasicSink.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_BASIC_SINK_HPP
#define SL_LOG_BASIC_SINK_HPP
 
#pragma once
 
#include "ISink.hpp"
#include "Record.hpp"
 
#include <atomic>
#include <chrono>
#include <functional>
#include <iomanip>
#include <mutex>
#include <sstream>
 
namespace sl::log
{
    template <class T, class TRecord>
    concept RecordFormatterFor =
        Record<TRecord> &&
        std::is_invocable_r_v<std::string, T, const TRecord&>;
 
    template <class T, class TRecord>
    concept RecordFilterFor =
        Record<TRecord> &&
        std::predicate<T, const TRecord&>;
 
    template <Record TRecord>
    class BasicSink :
        public ISink<TRecord>
    {
        using Super = ISink<TRecord>;
 
    public:
        using typename Super::Record_t;
        using Projections_t = RecordGetters<Record_t>;
        using Formatter_t = std::function<std::string(const Record_t&)>;
        using Filter_t = std::function<bool(const Record_t&)>;
 
    protected:
        static constexpr Formatter_t defaultFormatter() noexcept
        {
            return [](const Record_t& rec)
            {
                using namespace std::chrono;
                using namespace std::chrono_literals;
 
                // ToDo: replace with c++20 chrono and format
                const auto today = Projections_t::timePoint(rec).time_since_epoch() % 24h;
                const auto hour = duration_cast<hours>(today);
                const auto minute = duration_cast<minutes>(today) % 1h;
                const auto second = duration_cast<seconds>(today) % 1min;
                const auto millisecond = duration_cast<milliseconds>(today) % 1s;
 
                std::ostringstream out;
                out << std::setfill('0') <<
                    std::setw(2) << hour.count() << ":" <<
                    std::setw(2) << minute.count() << ":" <<
                    std::setw(2) << second.count() << "." <<
                    std::setw(3) << millisecond.count() <<
                    " >>> ";
 
                out << Projections_t::severity(rec) << ":: ";
                out << Projections_t::message(rec);
                return std::move(out).str();
            };
        }
 
        static constexpr Filter_t defaultFilter() noexcept
        {
            return [](const Record_t& rec) { return true; };
        }
 
    public:
        explicit BasicSink() noexcept = default;
 
        ~BasicSink() noexcept = default;
 
        BasicSink(const BasicSink&) = delete;
        BasicSink& operator =(const BasicSink&) = delete;
 
        BasicSink(BasicSink&&) = delete;
        BasicSink& operator =(BasicSink&&) = delete;
 
        void log(const Record_t& record) final override
        {
            if (!m_Enabled)
                return;
 
            if (std::scoped_lock lock{ m_FilterMx }; !std::invoke(m_Filter, record))
                return;
 
            const auto message = [&]
            {
                std::scoped_lock lock{ m_FormatterMx };
                return std::invoke(m_Formatter, record);
            }();
 
            writeMessage(record, message);
        }
 
        void setEnabled(bool enable = true) noexcept final override
        {
            m_Enabled = enable;
        }
 
        [[nodiscard]]
        bool isEnabled() const noexcept final override
        {
            return m_Enabled;
        }
 
        template <RecordFormatterFor<Record_t> TFormatter>
        void setFormatter(TFormatter&& formatter)
        {
            std::scoped_lock lock{ m_FormatterMx };
            m_Formatter = std::forward<TFormatter>(formatter);
        }
 
        void removeFormatter()
        {
            std::scoped_lock lock{ m_FormatterMx };
            m_Formatter = defaultFormatter();
        }
 
        template <RecordFilterFor<Record_t> TFilter>
        void setFilter(TFilter&& filter)
        {
            std::scoped_lock lock{ m_FilterMx };
            m_Filter = std::forward<TFilter>(filter);
        }
 
        void removeFilter()
        {
            std::scoped_lock lock{ m_FilterMx };
            m_Filter = defaultFilter();
        }
 
    protected:
        virtual void writeMessage(const Record_t& record, std::string_view message) = 0;
 
    private:
        std::mutex m_FormatterMx;
        Formatter_t m_Formatter{ defaultFormatter() };
 
        std::mutex m_FilterMx;
        Filter_t m_Filter{ defaultFilter() };
 
        std::atomic_bool m_Enabled{ false };
    };
 
}
 
#endif