child_of.hpp

 
#ifndef UFO_CONTAINER_TREE_PREDICATE_CHILD_OF_HPP
#define UFO_CONTAINER_TREE_PREDICATE_CHILD_OF_HPP
 
// UFO
#include <ufo/container/tree/code.hpp>
#include <ufo/container/tree/predicate/filter.hpp>
 
// STL
#include <algorithm>
#include <cstddef>
 
namespace ufo::pred
{
template <std::size_t Dim, bool Negated = false>
struct ChildOf {
    TreeCode<Dim> code;
 
    constexpr ChildOf(TreeCode<Dim> const& code) noexcept : code(code) {}
};
 
// Deduction guide
template <std::size_t Dim>
ChildOf(TreeCode<Dim>) -> ChildOf<Dim>;
 
template <std::size_t Dim, bool Negated>
[[nodiscard]] constexpr ChildOf<Dim, !Negated> operator!(
    ChildOf<Dim, Negated> const& p) noexcept
{
    return ChildOf<Dim, !Negated>{p.code};
}
 
template <std::size_t Dim, bool Negated>
struct Filter<ChildOf<Dim, Negated>> {
    using Pred = ChildOf<Dim, Negated>;
 
    template <class Tree>
    static constexpr void init(Pred&, Tree const&) noexcept
    {
    }
 
    template <class Value>
    [[nodiscard]] static constexpr bool returnableValue(Pred const&, Value const&) noexcept
    {
        return true;
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnable(Pred const& p, Tree const& t,
                                                   typename Tree::Node const& n) noexcept
    {
        if constexpr (Negated) {
            return !(p.code.depth() > t.depth(n) &&
                     TreeCode<Dim>::equalAtDepth(p.code, t.code(n), p.code.depth()));
        } else {
            return p.code.depth() > t.depth(n) &&
                   TreeCode<Dim>::equalAtDepth(p.code, t.code(n), p.code.depth());
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversable(Pred const& p, Tree const& t,
                                                    typename Tree::Node const& n) noexcept
    {
        if constexpr (Negated) {
            return returnable(p, t, n);
        } else {
            return TreeCode<Dim>::equalAtDepth(p.code, t.code(n),
                                               std::max(p.code.depth(), t.depth(n)));
        }
    }
 
    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_CHILD_OF_HPP