offset.hpp

 
#ifndef UFO_CONTAINER_TREE_PREDICATE_OFFSET_HPP
#define UFO_CONTAINER_TREE_PREDICATE_OFFSET_HPP
 
// UFO
#include <ufo/container/tree/predicate/filter.hpp>
 
namespace ufo::pred
{
template <bool Negated = false>
struct Offset {
    std::size_t offset;
 
    constexpr Offset(std::size_t offset = 0) noexcept : offset(offset) {}
};
 
template <bool Negated>
[[nodiscard]] Offset<!Negated> operator!(Offset<Negated> const& p)
{
    return Offset<!Negated>(p.offset);
}
 
static constexpr inline Offset<false> const offset;
 
template <bool Negated>
struct Filter<Offset<Negated>> {
    using Pred = Offset<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&,
                                                   typename Tree::Node const& n) noexcept
    {
        if constexpr (Negated) {
            return p.offset != n.code.offset();
        } else {
            return p.offset == n.code.offset();
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversable(Pred const&, Tree const&,
                                                    typename Tree::Node const&) noexcept
    {
        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_OFFSET_HPP