satisfies.hpp

 
#ifndef UFO_CONTAINER_TREE_PREDICATE_SATISFIES_HPP
#define UFO_CONTAINER_TREE_PREDICATE_SATISFIES_HPP
 
// UFO
#include <ufo/container/tree/predicate/filter.hpp>
 
// STL
#include <functional>
 
namespace ufo::pred
{
struct SatisfiesDefaultReturnFun {
    template <class... Args>
    [[nodiscard]] constexpr bool operator()(Args&&...) const noexcept
    {
        return true;
    }
};
 
struct SatisfiesDefaultTraverseFun {
    template <class... Args>
    [[nodiscard]] constexpr bool operator()(Args&&...) const noexcept
    {
        return true;
    }
};
 
template <class ReturnFun   = SatisfiesDefaultReturnFun,
          class TraverseFun = SatisfiesDefaultTraverseFun, bool Negated = false>
struct Satisfies {
    constexpr Satisfies() = default;
 
    constexpr Satisfies(ReturnFun ret_fun) : ret_fun(ret_fun) {}
 
    constexpr Satisfies(ReturnFun ret_fun, TraverseFun trav_fun)
        : ret_fun(ret_fun), trav_fun(trav_fun)
    {
    }
 
    ReturnFun   ret_fun;
    TraverseFun trav_fun;
};
 
template <class ReturnFun, class TraverseFun, bool Negated>
[[nodiscard]] constexpr Satisfies<ReturnFun, TraverseFun, !Negated> operator!(
    Satisfies<ReturnFun, TraverseFun, Negated> const& p) noexcept
{
    return Satisfies<ReturnFun, TraverseFun, !Negated>(p.ret_fun, p.trav_fun);
}
 
template <class ReturnFun, class TraverseFun, bool Negated>
struct Filter<Satisfies<ReturnFun, TraverseFun, Negated>> {
    using Pred = Satisfies<ReturnFun, TraverseFun, Negated>;
 
    template <class Tree>
    static constexpr void init(Pred&, Tree const&) noexcept
    {
    }
 
    template <class Value>
    [[nodiscard]] static constexpr bool returnableValue(Pred const&  p,
                                                        Value const& v) noexcept
    {
        if constexpr (std::is_invocable_r_v<bool, ReturnFun, Value const&>) {
            if constexpr (Negated) {
                return !std::invoke_r<bool>(p.ret_fun, v);
            } else {
                return std::invoke_r<bool>(p.ret_fun, v);
            }
        } else {
            return true;
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnable(Pred const& p, Tree const& t,
                                                   typename Tree::Node const& n) noexcept
    {
        if constexpr (std::is_invocable_r_v<bool, ReturnFun, Tree const&,
                                            typename Tree::Node const&>) {
            if constexpr (Negated) {
                return !std::invoke_r<bool>(p.ret_fun, t, n);
            } else {
                return std::invoke_r<bool>(p.ret_fun, t, n);
            }
        } else {
            return true;
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversable(Pred const& p, Tree const& t,
                                                    typename Tree::Node const& n) noexcept
    {
        if constexpr (std::is_invocable_r_v<bool, TraverseFun, Tree const&,
                                            typename Tree::Node const&>) {
            if constexpr (Negated) {
                return !std::invoke_r<bool>(p.trav_fun, t, n);
            } else {
                return std::invoke_r<bool>(p.trav_fun, t, n);
            }
        } else {
            return true;
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnableRay(Pred const& p, Tree const& t,
                                                      typename Tree::Node const& n,
                                                      typename Tree::Ray const&) noexcept
    {
        return returnable(p, t, n);
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversableRay(Pred const& p, Tree const& t,
                                                       typename Tree::Node const& n,
                                                       typename Tree::Ray const&) noexcept
    {
        return traversable(p, t, n);
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_CONTAINER_TREE_PREDICATE_SATISFIES_HPP