semantic_propagation.hpp

 
#ifndef UFO_MAP_SEMANTIC_PROPAGATION_HPP
#define UFO_MAP_SEMANTIC_PROPAGATION_HPP
 
// UFO
#include <ufo/container/range.hpp>
#include <ufo/map/semantic/semantic.hpp>
#include <ufo/map/types.hpp>
 
// STL
#include <algorithm>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
namespace ufo
{
class SemanticPropagation
{
 public:
    constexpr void setDefault(PropagationCriteria prop_criteria)
    {
        default_prop_criteria_ = prop_criteria;
    }
 
    void set(SemanticRange range, PropagationCriteria prop_criteria)
    {
        prop_criteria_.insert_or_assign(range, prop_criteria);
    }
 
    template <class InputIt>
    void set(InputIt first, InputIt last, PropagationCriteria prop_criteria)
    {
        std::for_each(first, last, [this, prop_criteria](auto r) { set(r, prop_criteria); });
    }
 
    void erase(SemanticRange range) { prop_criteria_.erase(range); }
 
    template <class InputIt>
    void erase(InputIt first, InputIt last)
    {
        std::for_each(first, last, [this](auto e) { erase(e); });
    }
 
    void clear() { prop_criteria_.clear(); }
 
    [[nodiscard]] bool empty() const { return prop_criteria_.empty(); }
 
    [[nodiscard]] constexpr PropagationCriteria defaultPropCriteria() const noexcept
    {
        return default_prop_criteria_;
    }
 
    [[nodiscard]] PropagationCriteria propCriteria(label_t label) const
    {
        auto it = prop_criteria_.find(label);
        return prop_criteria_.end() == it ? defaultPropCriteria() : it->second;
    }
 
 private:
    PropagationCriteria                    default_prop_criteria_;
    RangeMap<label_t, PropagationCriteria> prop_criteria_;
};
}  // namespace ufo
 
#endif  // UFO_MAP_SEMANTIC_PROPAGATION_HPP