misses.hpp

 
#ifndef UFO_MAP_MISSES_PREDICATE_MISSES_HPP
#define UFO_MAP_MISSES_PREDICATE_MISSES_HPP
 
// UFO
#include <ufo/map/predicate/predicate.hpp>
#include <ufo/map/predicate/predicate_compare.hpp>
#include <ufo/map/types.hpp>
 
namespace ufo::pred
{
template <PredicateCompare PC = PredicateCompare::EQUAL>
struct Misses {
    count_t misses;
 
    Misses(count_t misses) : misses(misses) {}
};
 
using MissesE  = Misses<>;
using MissesNE = Misses<PredicateCompare::NOT_EQUAL>;
using MissesLE = Misses<PredicateCompare::LESS_EQUAL>;
using MissesGE = Misses<PredicateCompare::GREATER_EQUAL>;
using MissesL  = Misses<PredicateCompare::LESS>;
using MissesG  = Misses<PredicateCompare::GREATER>;
 
using MissesMin = MissesGE;
using MissesMax = MissesLE;
 
template <PredicateCompare PC>
struct InnerCheck<Misses<PC>> {
    using Pred = Misses<PC>;
 
    template <class Map, class Node>
    static inline bool apply(Pred p, Map const& m, Node const& n)
    {
        switch (m.missesPropagationCriteria()) {
            case PropagationCriteria::MIN:
                if constexpr (PredicateCompare::EQUAL == PC) {
                    return m.misses(n.index()) <= p.misses;
                } else if constexpr (PredicateCompare::NOT_EQUAL == PC) {
                    return true;
                } else if constexpr (PredicateCompare::LESS_EQUAL == PC) {
                    return m.misses(n.index()) <= p.misses;
                } else if constexpr (PredicateCompare::GREATER_EQUAL == PC) {
                    return true;
                } else if constexpr (PredicateCompare::LESS == PC) {
                    return m.misses(n.index()) < p.misses;
                } else if constexpr (PredicateCompare::GREATER == PC) {
                    return true;
                }
            case PropagationCriteria::MAX:
                if constexpr (PredicateCompare::EQUAL == PC) {
                    return m.misses(n.index()) >= p.misses;
                } else if constexpr (PredicateCompare::NOT_EQUAL == PC) {
                    return true;
                } else if constexpr (PredicateCompare::LESS_EQUAL == PC) {
                    return true;
                } else if constexpr (PredicateCompare::GREATER_EQUAL == PC) {
                    return m.misses(n.index()) >= p.misses;
                } else if constexpr (PredicateCompare::LESS == PC) {
                    return true;
                } else if constexpr (PredicateCompare::GREATER == PC) {
                    return m.misses(n.index()) > p.misses;
                }
            case PropagationCriteria::MEAN: return true;
            case PropagationCriteria::NONE: return true;
        }
    }
};
 
template <PredicateCompare PC>
struct ValueCheck<Misses<PC>> {
    using Pred = Misses<PC>;
 
    template <class Map, class Node>
    static inline bool apply(Pred const& p, Map const& m, Node n)
    {
        if constexpr (PredicateCompare::EQUAL == PC) {
            return m.misses(n.index()) == p.misses;
        } else if constexpr (PredicateCompare::NOT_EQUAL == PC) {
            return m.misses(n.index()) != p.misses;
        } else if constexpr (PredicateCompare::LESS_EQUAL == PC) {
            return m.misses(n.index()) <= p.misses;
        } else if constexpr (PredicateCompare::GREATER_EQUAL == PC) {
            return m.misses(n.index()) >= p.misses;
        } else if constexpr (PredicateCompare::LESS == PC) {
            return m.misses(n.index()) < p.misses;
        } else if constexpr (PredicateCompare::GREATER == PC) {
            return m.misses(n.index()) > p.misses;
        }
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_MAP_MISSES_PREDICATE_MISSES_HPP