cost.hpp

 
#ifndef UFO_MAP_COST_PREDICATE_COST_HPP
#define UFO_MAP_COST_PREDICATE_COST_HPP
 
// UFO
#include <ufo/container/tree/index.hpp>
#include <ufo/container/tree/predicate/filter.hpp>
#include <ufo/container/tree/predicate/predicate_compare.hpp>
#include <ufo/map/cost/propagation_criteria.hpp>
 
// STL
#include <cassert>
 
namespace ufo::pred
{
template <PredicateCompare PC = PredicateCompare::EQUAL>
struct Cost {
    using cost_t = float;
 
    Cost(cost_t cost) : cost(cost) {}
 
    cost_t cost;
 
 protected:
    template <class T>
    friend class Filter;
};
 
using CostE  = Cost<>;
using CostNE = Cost<PredicateCompare::NOT_EQUAL>;
using CostLE = Cost<PredicateCompare::LESS_EQUAL>;
using CostGE = Cost<PredicateCompare::GREATER_EQUAL>;
using CostL  = Cost<PredicateCompare::LESS>;
using CostG  = Cost<PredicateCompare::GREATER>;
 
using CostMin = CostGE;
using CostMax = CostLE;
 
template <PredicateCompare PC>
struct Filter<Cost<PC>> {
    using Pred = Cost<PC>;
 
    template <class Tree>
    static constexpr void init(Pred& p, Tree const& t)
    {
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnable(Pred const& p, Tree const& t,
                                                   TreeIndex n)
    {
        if constexpr (PredicateCompare::EQUAL == PC) {
            return t.cost(n) == p.cost;
        } else if constexpr (PredicateCompare::NOT_EQUAL == PC) {
            return t.cost(n) != p.cost;
        } else if constexpr (PredicateCompare::LESS_EQUAL == PC) {
            return t.cost(n) <= p.cost;
        } else if constexpr (PredicateCompare::GREATER_EQUAL == PC) {
            return t.cost(n) >= p.cost;
        } else if constexpr (PredicateCompare::LESS == PC) {
            return t.cost(n) < p.cost;
        } else if constexpr (PredicateCompare::GREATER == PC) {
            return t.cost(n) > p.cost;
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversable(Pred const& p, Tree const& t,
                                                    TreeIndex n)
    {
        switch (t.costPropagationCriteria()) {
            case CostPropagationCriteria::MIN:
                if constexpr (PredicateCompare::EQUAL == PC) {
                    return t.cost(n) <= p.cost;
                } else if constexpr (PredicateCompare::NOT_EQUAL == PC) {
                    return true;
                } else if constexpr (PredicateCompare::LESS_EQUAL == PC) {
                    return t.cost(n) <= p.cost;
                } else if constexpr (PredicateCompare::GREATER_EQUAL == PC) {
                    return true;
                } else if constexpr (PredicateCompare::LESS == PC) {
                    return t.cost(n) < p.cost;
                } else if constexpr (PredicateCompare::GREATER == PC) {
                    return true;
                }
            case CostPropagationCriteria::MAX:
                if constexpr (PredicateCompare::EQUAL == PC) {
                    return t.cost(n) >= p.cost;
                } 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 t.cost(n) >= p.cost;
                } else if constexpr (PredicateCompare::LESS == PC) {
                    return true;
                } else if constexpr (PredicateCompare::GREATER == PC) {
                    return t.cost(n) > p.cost;
                }
            case CostPropagationCriteria::MEAN: return true;
            case CostPropagationCriteria::NONE: return true;
        }
        assert(false);
        return true;
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_MAP_COST_PREDICATE_COST_HPP