count_map.hpp

 
#ifndef UFO_MAP_COUNT_PREDICATE_COUNT_MAP_HPP
#define UFO_MAP_COUNT_PREDICATE_COUNT_MAP_HPP
 
// UFO
#include <ufo/map/count/is_count_map.hpp>
#include <ufo/map/predicate/predicate.hpp>
 
namespace ufo::pred
{
template <bool Negated = false>
struct CountMap {
 private:
    bool enabled;
 
    friend struct Init<CountMap>;
    friend struct InnerCheck<CountMap>;
    friend struct ValueCheck<CountMap>;
    friend struct ShaderInnerCheck<CountMap>;
    friend struct ShaderValueCheck<CountMap>;
};
 
template <bool Negated>
CountMap<!Negated> operator!(CountMap<Negated>)
{
    return {};
}
 
template <bool Negated>
struct Init<CountMap<Negated>> {
    using Pred = CountMap<Negated>;
 
    template <class Map>
    static inline void apply(Pred& p, Map const& m)
    {
        p.enabled = m.isMapTypesEnabled(MapType::COUNT);
    }
};
 
template <bool Negated>
struct InnerCheck<CountMap<Negated>> {
    using Pred = CountMap<Negated>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred p, Map const&, Node const&)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (Negated) {
                return !is_count_map_v<Map>;
            } else {
                return is_count_map_v<Map>;
            }
        } else {
            if constexpr (Negated) {
                return !p.enabled;
            } else {
                return p.enabled;
            }
        }
    }
};
 
template <bool Negated, class PredPost>
struct InnerCheck<Then<CountMap<Negated>, PredPost>> {
    using Pred = Then<CountMap<Negated>, PredPost>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred const& p, Map const& m, Node const& n)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (InnerCheck<CountMap<Negated>>::apply(p.pre, m, n)) {
                return InnerCheck<PredPost>::apply(p.post, m, n);
            } else {
                return true;
            }
        } else {
            return !InnerCheck<CountMap<Negated>>::apply(p.pre, m, n) ||
                   InnerCheck<PredPost>::apply(p.post, m, n);
        }
    }
};
 
template <bool Negated>
struct ValueCheck<CountMap<Negated>> {
    using Pred = CountMap<Negated>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred p, Map const&, Node const& n)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (Negated) {
                return !is_count_map_v<Map>;
            } else {
                return is_count_map_v<Map>;
            }
        } else {
            if constexpr (Negated) {
                return !p.enabled;
            } else {
                return p.enabled;
            }
        }
    }
};
 
template <bool Negated, class PredPost>
struct ValueCheck<Then<CountMap<Negated>, PredPost>> {
    using Pred = Then<CountMap<Negated>, PredPost>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred const& p, Map const& m, Node const& n)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (ValueCheck<CountMap<Negated>>::apply(p.pre, m, n)) {
                return ValueCheck<PredPost>::apply(p.post, m, n);
            } else {
                return true;
            }
        } else {
            return !ValueCheck<CountMap<Negated>>::apply(p.pre, m, n) ||
                   ValueCheck<PredPost>::apply(p.post, m, n);
        }
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_MAP_COUNT_PREDICATE_COUNT_MAP_HPP