FlushPolicies.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_FLUSH_POLICIES_HPP
#define SL_LOG_FLUSH_POLICIES_HPP
 
#pragma once
 
#include "Record.hpp"
#include "TupleAlgorithms.hpp"
 
#include <chrono>
#include <concepts>
#include <cstddef>
#include <functional>
#include <type_traits>
#include <utility>
 
namespace sl::log
{
    template <class T, class TRecord>
    concept FlushPolicyFor =
    Record<TRecord> &&
    std::predicate<T, const TRecord&, std::size_t> &&
    requires(T policy)
    {
        { policy.flushed() };
    };
}
 
namespace sl::log::detail
{
    template <Record TRecord>
    class AbstractFlushPolicyWrapper
    {
    public:
        using Record_t = std::remove_cvref_t<TRecord>;
 
        virtual ~AbstractFlushPolicyWrapper() noexcept = default;
 
        AbstractFlushPolicyWrapper(const AbstractFlushPolicyWrapper&) = delete;
        AbstractFlushPolicyWrapper& operator =(const AbstractFlushPolicyWrapper&) = delete;
        AbstractFlushPolicyWrapper(AbstractFlushPolicyWrapper&&) = delete;
        AbstractFlushPolicyWrapper& operator =(AbstractFlushPolicyWrapper&&) = delete;
 
        virtual bool operator ()(const Record_t& record, std::size_t messageByteSize) = 0;
        virtual void flushed() = 0;
 
    protected:
        AbstractFlushPolicyWrapper() noexcept = default;
    };
 
    template <Record TRecord, FlushPolicyFor<TRecord> TFlushPolicy>
    class FlushPolicyWrapper final :
        public AbstractFlushPolicyWrapper<TRecord>
    {
        using Super = AbstractFlushPolicyWrapper<TRecord>;
    public:
        using typename Super::Record_t;
        using FlushPolicy_t = std::remove_reference_t<TFlushPolicy>;
 
        explicit FlushPolicyWrapper() noexcept(std::is_nothrow_constructible_v<FlushPolicy_t>) :
            m_FlushPolicy{}
        {
        }
 
        explicit FlushPolicyWrapper(TFlushPolicy flushPolicy) noexcept(std::is_nothrow_move_constructible_v<FlushPolicy_t>) :
            m_FlushPolicy{ std::move(flushPolicy) }
        {
        }
 
        bool operator ()(const Record_t& record, std::size_t messageByteSize) override
        {
            return std::invoke(m_FlushPolicy, record, messageByteSize);
        }
 
        void flushed() override
        {
            m_FlushPolicy.flushed();
        }
 
    private:
        FlushPolicy_t m_FlushPolicy;
    };
 
    template <auto VConstant>
    struct ConstantInvokable
    {
        template <class... TArgs>
        constexpr auto operator()(TArgs&&...) const noexcept
        {
            return VConstant;
        }
    };
 
    struct PredProjInvocation
    {
        template <class TPredicate, class TProjection, class TProjected, class... TArgs>
        constexpr auto operator ()(TPredicate& pred, TProjection& proj, const TProjected& projected, TArgs&&... args) const
        {
            return std::invoke(pred, std::invoke(proj, projected), std::forward<TArgs>(args)...);
        }
    };
 
    struct PredProjInvocationIgnoreArgs
    {
        template <class TPredicate, class TProjection, class TProjected, class... TArgs>
        constexpr auto operator ()(TPredicate& pred, TProjection& proj, const TProjected& projected, TArgs&&...) const
        {
            return std::invoke(pred, std::invoke(proj, projected));
        }
    };
}
 
namespace sl::log
{
    template <class TPredicate, class TProjection = std::identity, class TInvocationRule = detail::PredProjInvocation>
    class FlushPolicy
    {
    public:
        using Predicate_t = std::remove_cvref_t<TPredicate>;
        using Projection_t = std::remove_cvref_t<TProjection>;
        using InvocationRule_t = std::remove_cvref_t<TInvocationRule>;
 
        explicit FlushPolicy(
            TPredicate predicate = Predicate_t{},
            TProjection projection = Projection_t{},
            TInvocationRule invocation = InvocationRule_t{}
        )
        noexcept(std::is_nothrow_move_constructible_v<TPredicate> && std::is_nothrow_move_constructible_v<TProjection> &&
                std::is_nothrow_move_constructible_v<TInvocationRule>) :
            m_Predicate{ std::move(predicate) },
            m_Projection{ std::move(projection) },
            m_Invocation{ std::move(invocation) }
        {
        }
 
        template <class... TArgs>
        requires std::constructible_from<Predicate_t, TArgs...>
        explicit FlushPolicy(
            std::in_place_t _,
            TArgs&&... args
        )
        noexcept(std::is_nothrow_constructible_v<TPredicate, TArgs...> && std::is_nothrow_constructible_v<TProjection> &&
                std::is_nothrow_constructible_v<TInvocationRule>) :
            m_Predicate{ std::forward<TArgs>(args)... }
        {
        }
 
        template <Record TRecord>
        bool operator ()(const TRecord& record, std::size_t messageByteSize)
        {
            return m_Invocation(m_Predicate, m_Projection, record, messageByteSize);
        }
 
        constexpr void flushed() const noexcept
        {
        }
 
    private:
        Predicate_t m_Predicate;
        Projection_t m_Projection;
        //[[no_unique_address]]
        InvocationRule_t m_Invocation;
    };
 
    template <class TAlgorithm, class... TFlushPolicies>
    class FlushPolicyChain
    {
    public:
        using Algorithm_t = TAlgorithm;
 
        constexpr explicit FlushPolicyChain(
            TFlushPolicies ... policies
        )
        noexcept(std::is_nothrow_constructible_v<Algorithm_t> && (std::is_nothrow_move_constructible_v<TFlushPolicies> && ...)) :
            m_Algorithm{},
            m_Policies{ std::move(policies)... }
        {
        }
 
        constexpr explicit FlushPolicyChain(
            TAlgorithm algorithm,
            TFlushPolicies ... policies
        )
        noexcept(std::is_nothrow_move_constructible_v<Algorithm_t> && (std::is_nothrow_move_constructible_v<TFlushPolicies> && ...
                )
        ) :
            m_Algorithm{ std::move(algorithm) },
            m_Policies{ std::forward<TFlushPolicies>(policies)... }
        {
        }
 
        template <Record TRecord>
        bool operator ()(const TRecord& record, std::size_t messageByteSize)
        {
            return std::invoke(m_Algorithm, m_Policies, record, messageByteSize);
        }
 
        constexpr void flushed()
        {
            detail::TupleForEach{}(
                                    m_Policies,
                                    [](auto&& policy)
                                    {
                                        policy.flushed();
                                    }
                                );
        }
 
        [[nodiscard]]
        constexpr bool empty() const noexcept
        {
            return std::tuple_size_v<decltype(m_Policies)> == 0;
        }
 
        [[nodiscard]]
        constexpr std::size_t size() const noexcept
        {
            return std::tuple_size_v<decltype(m_Policies)>;
        }
 
    private:
        Algorithm_t m_Algorithm;
        std::tuple<TFlushPolicies...> m_Policies;
    };
 
    template <class... TFlushPolicies>
    class FlushPolicyAllOf :
        public FlushPolicyChain<detail::TupleAllOf, TFlushPolicies...>
    {
        using Algorithm_t = detail::TupleAllOf;
 
    public:
        constexpr explicit FlushPolicyAllOf(
            TFlushPolicies ... policies
        )
        noexcept((std::is_nothrow_move_constructible_v<TFlushPolicies> && ...)) :
            FlushPolicyChain<Algorithm_t, TFlushPolicies...>{ std::move(policies)... }
        {
        }
    };
 
    template <class... TFlushPolicies>
    class FlushPolicyAnyOf :
        public FlushPolicyChain<detail::TupleAnyOf, TFlushPolicies...>
    {
        using Algorithm_t = detail::TupleAnyOf;
 
    public:
        constexpr explicit FlushPolicyAnyOf(
            TFlushPolicies ... policies
        )
        noexcept((std::is_nothrow_move_constructible_v<TFlushPolicies> && ...)) :
            FlushPolicyChain<Algorithm_t, TFlushPolicies...>{ std::move(policies)... }
        {
        }
    };
 
    template <class... TFlushPolicies>
    class FlushPolicyNoneOf :
        public FlushPolicyChain<detail::TupleNoneOf, TFlushPolicies...>
    {
        using Algorithm_t = detail::TupleNoneOf;
 
    public:
        constexpr explicit FlushPolicyNoneOf(
            TFlushPolicies ... policies
        )
        noexcept((std::is_nothrow_move_constructible_v<TFlushPolicies> && ...)) :
            FlushPolicyChain<Algorithm_t, TFlushPolicies...>{ std::move(policies)... }
        {
        }
    };
 
    using AlwaysFlushPolicy = FlushPolicy<detail::ConstantInvokable<true>>;
 
    template <Record TRecord, std::predicate<const RecordMessage_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeMessageFlushPolicyFor(TUnaryPredicate&& predicate)
    {
        return FlushPolicy{
            std::forward<TUnaryPredicate>(predicate),
            RecordGetters<TRecord>::message,
            detail::PredProjInvocationIgnoreArgs{}
        };
    }
 
    template <Record TRecord, std::predicate<const RecordSeverity_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeSeverityFlushPolicyFor(TUnaryPredicate&& predicate)
    {
        return FlushPolicy{
            std::forward<TUnaryPredicate>(predicate),
            RecordGetters<TRecord>::severity,
            detail::PredProjInvocationIgnoreArgs{}
        };
    }
 
    template <Record TRecord, std::predicate<const RecordChannel_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeChannelFlushPolicyFor(TUnaryPredicate&& predicate)
    {
        return FlushPolicy{
            std::forward<TUnaryPredicate>(predicate),
            RecordGetters<TRecord>::channel,
            detail::PredProjInvocationIgnoreArgs{}
        };
    }
 
    template <Record TRecord, std::predicate<const RecordTimePoint_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeTimePointFlushPolicyFor(TUnaryPredicate&& predicate)
    {
        return FlushPolicy{
            std::forward<TUnaryPredicate>(predicate),
            RecordGetters<TRecord>::timePoint,
            detail::PredProjInvocationIgnoreArgs{}
        };
    }
 
    class TimedFlushPolicy
    {
    public:
        using Duration_t = std::chrono::milliseconds;
        using Clock_t = std::chrono::steady_clock;
        using TimePoint_t = Clock_t::time_point;
 
        template <class TRep, class TPeriod>
        explicit TimedFlushPolicy(std::chrono::duration<TRep, TPeriod> duration) :
            m_Duration{ std::chrono::duration_cast<Duration_t>(duration) }
        {
        }
 
        template <Record TRecord>
        bool operator ()(const TRecord& record, std::size_t messageByteSize) noexcept
        {
            const auto now = Clock_t::now();
            return m_Duration <= now - m_StartPoint;
        }
 
        void flushed() noexcept
        {
            m_StartPoint = Clock_t::now();
        }
 
    private:
        TimePoint_t m_StartPoint = Clock_t::now();
        Duration_t m_Duration;
    };
 
    class ByteCountFlushPolicy
    {
    public:
        explicit ByteCountFlushPolicy(std::size_t byteThreshold) noexcept :
            m_ByteThreshold{ byteThreshold }
        {
        }
 
        template <Record TRecord>
        bool operator ()(const TRecord& record, std::size_t messageByteSize) noexcept
        {
            m_ByteCount += messageByteSize;
            return m_ByteThreshold <= m_ByteCount;
        }
 
        void flushed() noexcept
        {
            m_ByteCount = 0;
        }
 
    private:
        std::size_t m_ByteThreshold;
        std::size_t m_ByteCount = 0;
    };
 
}
 
#endif