length.hpp

 
#ifndef UFO_CONTAINER_TREE_PREDICATE_LENGTH_HPP
#define UFO_CONTAINER_TREE_PREDICATE_LENGTH_HPP
 
// UFO
#include <ufo/container/tree/predicate/depth.hpp>
#include <ufo/container/tree/predicate/filter.hpp>
#include <ufo/container/tree/predicate/predicate_interval.hpp>
 
// TODO: Implement
 
namespace ufo::pred
{
namespace detail
{
struct Length {
    using value_type = double;
 
    int min_depth{};
    int max_depth{};
};
}  // namespace detail
 
template <bool Negated = false>
using Length = PredicateInterval<detail::Length, Negated>;
 
static constexpr inline Length<false> const length;
 
template <bool Negated>
struct Filter<Length<Negated>> {
    using Pred = Length<Negated>;
 
    template <class Tree>
    static constexpr void init(Pred& p, Tree const& t) noexcept
    {
        int min_d = -1;
        int max_d = -1;
        int num   = t.maxNumDepthLevels();
        for (int d{}; d < num; ++d) {
            auto l = t.length(d);
            if (p.min >= l && p.max >= l) {
                min_d = -1 == min_d ? d : min_d;
                max_d = d;
            }
        }
 
        if (min_d > 0 && max_d > 0) {
            p.min_depth = min_d;
            p.max_depth = max_d;
            return;
        }
 
        if constexpr (Negated) {
            p.min_depth = std::numeric_limits<int>::lowest();
            p.max_depth = std::numeric_limits<int>::max();
        } else {
            p.min_depth = std::numeric_limits<int>::max();
            p.max_depth = std::numeric_limits<int>::lowest();
        }
    }
 
    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
    {
        // Cast to int to prevent int to be promoted to unsigned
        int depth = static_cast<int>(t.depth(n));
        if constexpr (Negated) {
            return p.min_depth > depth || p.max_depth < depth;
        } else {
            return p.min_depth <= depth && p.max_depth >= depth;
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversable(Pred const& p, Tree const& t,
                                                    typename Tree::Node const& n) noexcept
    {
        // Cast to int to prevent int to be promoted to unsigned
        int depth = static_cast<int>(t.depth(n));
        if constexpr (Negated) {
            return 0 < p.min_depth || p.max_depth + 1 < depth;
        } else {
            return p.min_depth < depth;
        }
    }
 
    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_LENGTH_HPP