occupancy_map.hpp

 
#ifndef UFO_MAP_OCCUPANCY_PREDICATE_OCCUPANCY_MAP_HPP
#define UFO_MAP_OCCUPANCY_PREDICATE_OCCUPANCY_MAP_HPP
 
// UFO
#include <ufo/container/tree/predicate/filter.hpp>
 
namespace ufo::pred
{
template <bool Negated = false>
struct OccupancyMap {
 private:
    bool enabled;
 
    friend struct Init<OccupancyMap>;
    friend struct InnerCheck<OccupancyMap>;
    friend struct ValueCheck<OccupancyMap>;
    friend struct ShaderInnerCheck<OccupancyMap>;
    friend struct ShaderValueCheck<OccupancyMap>;
};
 
template <bool Negated>
OccupancyMap<!Negated> operator!(OccupancyMap<Negated>)
{
    return {};
}
 
template <bool Negated>
struct Init<OccupancyMap<Negated>> {
    using Pred = OccupancyMap<Negated>;
 
    template <class Map>
    static inline void apply(Pred& p, Map const& m)
    {
        p.enabled = m.isMapTypesEnabled(MapType::OCCUPANCY);
    }
};
 
template <bool Negated>
struct InnerCheck<OccupancyMap<Negated>> {
    using Pred = OccupancyMap<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_occupancy_map_v<Map>;
            } else {
                return is_occupancy_map_v<Map>;
            }
        } else {
            if constexpr (Negated) {
                return !p.enabled;
            } else {
                return p.enabled;
            }
        }
    }
};
 
template <bool Negated, class PredPost>
struct InnerCheck<Then<OccupancyMap<Negated>, PredPost>> {
    using Pred = Then<OccupancyMap<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<OccupancyMap<Negated>>::apply(p.pre, m, n)) {
                return InnerCheck<PredPost>::apply(p.post, m, n);
            } else {
                return true;
            }
        } else {
            return !InnerCheck<OccupancyMap<Negated>>::apply(p.pre, m, n) ||
                   InnerCheck<PredPost>::apply(p.post, m, n);
        }
    }
};
 
template <bool Negated>
struct ValueCheck<OccupancyMap<Negated>> {
    using Pred = OccupancyMap<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_occupancy_map_v<Map>;
            } else {
                return is_occupancy_map_v<Map>;
            }
        } else {
            if constexpr (Negated) {
                return !p.enabled;
            } else {
                return p.enabled;
            }
        }
    }
};
 
template <bool Negated, class PredPost>
struct ValueCheck<Then<OccupancyMap<Negated>, PredPost>> {
    using Pred = Then<OccupancyMap<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<OccupancyMap<Negated>>::apply(p.pre, m, n)) {
                return ValueCheck<PredPost>::apply(p.post, m, n);
            } else {
                return true;
            }
        } else {
            return !ValueCheck<OccupancyMap<Negated>>::apply(p.pre, m, n) ||
                   ValueCheck<PredPost>::apply(p.post, m, n);
        }
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_MAP_OCCUPANCY_PREDICATE_OCCUPANCY_MAP_HPP