Filters.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_FILTERS_HPP
#define SL_LOG_FILTERS_HPP
 
#pragma once
 
#include "Record.hpp"
#include "TupleAlgorithms.hpp"
 
#include <algorithm>
#include <concepts>
#include <functional>
#include <tuple>
#include <type_traits>
 
namespace sl::log
{
    template <class TProjection, class TUnaryPredicate>
    class ProjectionFilter
    {
    public:
        using Projection_t = std::remove_cvref_t<TProjection>;
        using UnaryPredicate_t = std::remove_cvref_t<TUnaryPredicate>;
 
        constexpr ProjectionFilter(
            TProjection projection,
            TUnaryPredicate predicate
        )
        noexcept(std::is_nothrow_move_constructible_v<Projection_t> && std::is_nothrow_move_constructible_v<UnaryPredicate_t>) :
            m_Projection{ std::move(projection) },
            m_Predicate{ std::move(predicate) }
        {
        }
 
        template <Record TRecord>
        constexpr bool operator ()(const TRecord& rec)
        {
            return std::invoke(m_Predicate, std::invoke(m_Projection, rec));
        }
 
    private:
        Projection_t m_Projection;
        UnaryPredicate_t m_Predicate;
    };
 
    template <class TAlgorithm, class... TFilter>
    class FilterChain
    {
    public:
        using Algorithm_t = std::remove_cvref_t<TAlgorithm>;
 
        constexpr explicit FilterChain(
            TFilter ...filter
        )
        noexcept(std::is_nothrow_constructible_v<Algorithm_t> && (std::is_nothrow_move_constructible_v<TFilter> && ...)) :
            m_Algorithm{},
            m_Filter{ std::move(filter)... }
        {
        }
 
        constexpr explicit FilterChain(
            TAlgorithm algorithm,
            TFilter ...filter
        ) noexcept(std::is_nothrow_move_constructible_v<Algorithm_t> && (std::is_nothrow_move_constructible_v<TFilter> && ...)) :
            m_Algorithm{ std::move(algorithm) },
            m_Filter{ std::forward<TFilter>(filter)... }
        {
        }
 
        template <Record TRecord>
        constexpr bool operator()(const TRecord& rec)
        {
            return std::invoke(m_Algorithm, m_Filter, rec);
        }
 
        [[nodiscard]]
        constexpr bool empty() const noexcept
        {
            return std::tuple_size_v<decltype(m_Filter)> == 0;
        }
 
        [[nodiscard]]
        constexpr std::size_t size() const noexcept
        {
            return std::tuple_size_v<decltype(m_Filter)>;
        }
 
    private:
        Algorithm_t m_Algorithm;
        std::tuple<TFilter...> m_Filter;
    };
 
    //ToDo: Clang currently doesn't support alias CTAD: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1814r0.html
    //template <std::predicate<const Record&>... TFilter>
    //using FilterDisjunction = FilterChain<FilterAllOf, TFilter...>;
    // 
    //template <std::predicate<const Record&>... TFilter>
    //using FilterConjunction = FilterChain<FilterAnyOf, TFilter...>;
 
    template <class... TFilter>
    class FilterAllOf :
        public FilterChain<detail::TupleAllOf, TFilter...>
    {
        using Algorithm_t = detail::TupleAllOf;
 
    public:
        constexpr explicit FilterAllOf(
            TFilter ... filter
        )
        noexcept((std::is_nothrow_move_constructible_v<TFilter> && ...)) :
            FilterChain<Algorithm_t, TFilter...>{ std::move(filter)... }
        {
        }
    };
 
    template <class... TFilter>
    class FilterAnyOf :
        public FilterChain<detail::TupleAnyOf, TFilter...>
    {
        using Algorithm_t = detail::TupleAnyOf;
 
    public:
        constexpr explicit FilterAnyOf(
            TFilter ... filter
        )
        noexcept((std::is_nothrow_move_constructible_v<TFilter> && ...)) :
            FilterChain<Algorithm_t, TFilter...>{ std::move(filter)... }
        {
        }
    };
 
    template <class... TFilter>
    class FilterNoneOf :
        public FilterChain<detail::TupleNoneOf, TFilter...>
    {
        using Algorithm_t = detail::TupleNoneOf;
 
    public:
        constexpr explicit FilterNoneOf(
            TFilter ... filter
        )
        noexcept((std::is_nothrow_move_constructible_v<TFilter> && ...)) :
            FilterChain<Algorithm_t, TFilter...>{ std::move(filter)... }
        {
        }
    };
 
    template <Record TRecord, std::predicate<const RecordMessage_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeMessageFilterFor(TUnaryPredicate&& predicate)
    {
        return ProjectionFilter{ RecordGetters<TRecord>::message, std::forward<TUnaryPredicate>(predicate) };
    }
 
    template <Record TRecord, std::predicate<const RecordSeverity_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeSeverityFilterFor(TUnaryPredicate&& predicate)
    {
        return ProjectionFilter{ RecordGetters<TRecord>::severity, std::forward<TUnaryPredicate>(predicate) };
    }
 
    template <Record TRecord, std::predicate<const RecordChannel_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeChannelFilterFor(TUnaryPredicate&& predicate)
    {
        return ProjectionFilter{ RecordGetters<TRecord>::channel, std::forward<TUnaryPredicate>(predicate) };
    }
 
    template <Record TRecord, std::predicate<const RecordTimePoint_t<TRecord>&> TUnaryPredicate>
    constexpr auto makeTimePointFilterFor(TUnaryPredicate&& predicate)
    {
        return ProjectionFilter{ RecordGetters<TRecord>::timePoint, std::forward<TUnaryPredicate>(predicate) };
    }
 
}
 
#endif