OStreamSink.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_OSTREAM_SINK_HPP
#define SL_LOG_OSTREAM_SINK_HPP
 
#pragma once
 
#include "BasicSink.hpp"
#include "FlushPolicies.hpp"
#include "Record.hpp"
 
#include <memory>
#include <mutex>
#include <ostream>
#include <string_view>
 
namespace sl::log
{
    template <Record TRecord>
    class OStreamSink :
        public BasicSink<TRecord>
    {
        using Super = BasicSink<TRecord>;
 
    public:
        using typename Super::Record_t;
        using typename Super::Formatter_t;
        using typename Super::Filter_t;
        using FlushPolicy_t = std::unique_ptr<detail::AbstractFlushPolicyWrapper<Record_t>>;
 
    protected:
        [[nodiscard]]
        static constexpr FlushPolicy_t defaultFlushPolicy() noexcept
        {
            return std::make_unique<detail::FlushPolicyWrapper<Record_t, AlwaysFlushPolicy>>();
        }
 
    public:
        explicit OStreamSink(std::ostream& stream) :
            Super{},
            m_Stream{ stream }
        {
        }
 
        ~OStreamSink() noexcept = default;
 
        OStreamSink(const OStreamSink&) = delete;
        OStreamSink& operator =(const OStreamSink&) = delete;
 
        OStreamSink(OStreamSink&&) = delete;
        OStreamSink& operator =(OStreamSink&&) = delete;
 
        template <FlushPolicyFor<Record_t> TPolicy>
        void setFlushPolicy(TPolicy&& policy)
        {
            std::scoped_lock lock{ m_FlushPolicyMx };
            m_FlushPolicy = std::make_unique<detail::FlushPolicyWrapper<TRecord, TPolicy>>(std::forward<TPolicy>(policy));
        }
 
        void removeFlushPolicy()
        {
            std::scoped_lock lock{ m_FlushPolicyMx };
            m_FlushPolicy = defaultFlushPolicy();
        }
 
        void flush()
        {
            std::scoped_lock lock{ m_StreamMx };
            flushImpl();
        }
 
    protected:
        template <class TData>
        void writeToStream(TData&& data)
        {
            std::scoped_lock lock{ m_StreamMx };
            m_Stream << std::forward<TData>(data);
            flushImpl();
        }
 
        virtual void beforeMessageWrite(const Record_t& record, std::string_view message)
        {
        }
 
        virtual void afterMessageWrite(const Record_t& record, std::string_view message)
        {
        }
 
    private:
        std::recursive_mutex m_StreamMx;
        std::ostream& m_Stream;
 
        std::mutex m_FlushPolicyMx;
        FlushPolicy_t m_FlushPolicy{ defaultFlushPolicy() };
 
        void handleFlushPolicy(const Record_t& record, std::size_t messageByteSize)
        {
            if (std::scoped_lock lock{ m_FlushPolicyMx }; !std::invoke(*m_FlushPolicy, record, messageByteSize))
                return;
 
            flushImpl();
        }
 
        void flushImpl()
        {
            m_Stream << std::flush;
            m_FlushPolicy->flushed();
        }
 
        void writeMessage(const Record_t& record, std::string_view message) final override
        {
            const auto msgSize = std::size(message) * sizeof(std::string_view::value_type);
 
            std::scoped_lock lock{ m_StreamMx };
            beforeMessageWrite(record, message);
            m_Stream << message << "\n";
            afterMessageWrite(record, message);
            handleFlushPolicy(record, msgSize);
        }
    };
 
}
 
#endif