mConfigurationMap.h

#pragma once
 
#include <utils/printer.h>
#include <state/mConfiguration/mConfiguration.h>
 
namespace TuringSim::State::MConfiguration {
    template<typename NodeType, typename V>
    class MConfigurationMap;
 
    template <typename T, typename V>
    class PureVariableException : public Utils::MessageException
    {
    public:
        PureVariableException() = delete;
 
        PureVariableException(
                std::string message,
                const MConfiguration<T>& key,
                const V& value,
                const MConfigurationMap<T, V>& map) :
                MessageException(message),
                key(key),
                value(value),
                map(map)
        {}
 
    protected:
        virtual std::string makeFullMessage() const override {
            using Utils::Debug::operator<<;
            std::ostringstream ss;
            ss << this->msg << std::endl;
            ss << "  pattern: " << key << std::endl;
            ss << "  state: " << value << std::endl;
            ss << "  map: " << map.debug() << std::endl;
            return ss.str();
        }
 
        MConfiguration<T> key;
 
        V value;
 
        const MConfigurationMap<T, V>& map;
    };
 
    template<typename NodeType, typename V>
    class MConfigurationMap {
    public:
        typedef MConfiguration<NodeType> MConf;
 
        typedef typename MConf::Unification Unification;
 
        MConfigurationMap() : pattern_map() {}
 
        void insert(const MConf& key, const V& val) {
            if(key.isVariable()) {
                throw PureVariableException<NodeType, V>("Cannot add a pure variable in a MConfigurationMap", key, val, *this);
            }
            const NodeType& root = key.getNode();
            size_t arity = key.getArity();
            typename std::map<std::pair<NodeType, int>, std::map<MConf, std::set<V>>>::iterator it = pattern_map.find({root, arity});
            if(it == pattern_map.end()) {
                pattern_map[{root, arity}] = {{key, {val}}};
            }
            else if (it->second.count(key) > 0) {
                it->second[key].insert(val);
            }
            else {
                it->second.insert({key, {val}});
            }
        }
 
        const std::map<MConf, std::set<V>>& getCandidates(const MConf& state) const {
            const NodeType& root = state.getNode();
            size_t arity = state.getArity();
            return pattern_map.at({root, arity});
        }
 
        std::map<MConf, std::set<std::pair<V, Unification>>> getMatching(const std::shared_ptr<const MConf>& state) const {
            const NodeType& root = state->getNode();
            size_t arity = state->getArity();
            typename std::map<std::pair<NodeType, int>, std::map<MConf, std::set<V>>>::const_iterator it = pattern_map.find({root, arity});
            if(it == pattern_map.end()) {
                return std::map<MConf, std::set<std::pair<V, Unification>>>();
            }
            const std::map<MConf, std::set<V>>& candidates = it->second;
 
            std::map<MConf, std::set<std::pair<V, Unification>>> matching_map;
            for(const auto& [pattern, values] : candidates) {
                for(const V& val: values) {
                    std::optional<Unification> unification_opt = pattern.unifyWithMConf_opt(state);
                    if(unification_opt) {
                        matching_map[pattern].insert({val, *unification_opt});
                    }
                }
            }
            return matching_map;
        }
 
        template<typename CharT = char, typename Traits = std::char_traits<CharT>>
        std::function<std::basic_ostream<CharT, Traits>&(std::basic_ostream<CharT, Traits>&)> debug() const {
            return Utils::Debug::debug<decltype(pattern_map), CharT, Traits>(pattern_map);
        }
 
    private:
        std::map<
                std::pair<NodeType, int>,  //  Root node of the mConfiguration, the arity
                std::map<MConf, std::set<V>>
        > pattern_map;
    };
}