hits_interval.hpp

 
#ifndef UFO_MAP_HITS_PREDICATE_HITS_INTERVAL_HPP
#define UFO_MAP_HITS_PREDICATE_HITS_INTERVAL_HPP
 
// UFO
#include <ufo/map/predicate/predicate.hpp>
#include <ufo/map/reflection/predicate/hits.hpp>
 
namespace ufo::pred
{
template <bool Negated = false>
struct HitsInterval {
    HitsMin min;
    HitsMax max;
 
    HitsInterval(count_t min, count_t max) : min(min), max(max) {}
};
 
template <bool Negated>
HitsInterval<!Negated> operator!(HitsInterval<Negated> p)
{
    return {p.min, p.max};
}
 
template <bool Negated>
struct Init<HitsInterval<Negated>> {
    using Pred = HitsInterval<Negated>;
 
    template <class Map>
    static inline void apply(Pred& p, Map const& m)
    {
        Init<std::decay_t<decltype(p.min)>>::apply(p.min, m);
        Init<std::decay_t<decltype(p.max)>>::apply(p.max, m);
    }
};
 
template <bool Negated>
struct InnerCheck<HitsInterval<Negated>> {
    using Pred = HitsInterval<Negated>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred const& p, Map const& m, Node const& n)
    {
        if constexpr (Negated) {
            return true;
        } else {
            return InnerCheck<std::decay_t<decltype(p.min)>>::apply(p.min, m, n) &&
                   InnerCheck<std::decay_t<decltype(p.max)>>::apply(p.max, m, n);
        }
    }
};
 
template <bool Negated>
struct ValueCheck<HitsInterval<Negated>> {
    using Pred = HitsInterval<Negated>;
 
    template <class Map, class Node>
    static inline bool apply(Pred const& p, Map const& m, Node const& n)
    {
        if constexpr (Negated) {
            return !ValueCheck<std::decay_t<decltype(p.min)>>::apply(p.min, m, n) &&
                   !ValueCheck<std::decay_t<decltype(p.max)>>::apply(p.max, m, n);
        } else {
            return ValueCheck<std::decay_t<decltype(p.min)>>::apply(p.min, m, n) &&
                   ValueCheck<std::decay_t<decltype(p.max)>>::apply(p.max, m, n);
        }
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_MAP_HITS_PREDICATE_HITS_INTERVAL_HPP