turingMachineSymbolPattern.h

#pragma once
 
#include <utils/visitor.h>
#include <state/mConfiguration/mConfiguration.h>
#include <symbol/symbolPattern.h>
 
namespace TuringSim::Symbol {
 
    template <typename T>
    class TuringStyleConstantSymbolPattern : public SymbolPattern<T, void>
    {
    public:
        constexpr explicit TuringStyleConstantSymbolPattern(bool neg) : neg(neg) {}
        constexpr TuringStyleConstantSymbolPattern(const T& e) : symbols({e}) {}
        constexpr TuringStyleConstantSymbolPattern(const std::set<T>& v) : symbols(v) {}
        constexpr TuringStyleConstantSymbolPattern(const std::set<T>& v, bool b) : symbols(v), neg(b) {}
        virtual bool match(const T& e) const override { return (symbols.find(e) == symbols.end()) == neg; }
 
        constexpr bool operator==(const TuringStyleConstantSymbolPattern<T>& other) const { return neg == other.neg && symbols == other.symbols; }
 
        constexpr bool operator!=(const TuringStyleConstantSymbolPattern<T>& other) const { return neg != other.neg || symbols != other.symbols; }
 
        constexpr bool operator<(const TuringStyleConstantSymbolPattern<T>& other) const {
            if(neg < other.neg) {
                return true;
            }
            if(neg > other.neg) {
                return false;
            }
            return symbols < other.symbols;
        }
 
        template <typename CharT = char, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits> &operator<<(std::basic_ostream<CharT, Traits>& os, const TuringStyleConstantSymbolPattern& pattern) {
            bool first = true;
            if(pattern.neg) {
                os << "non";
            }
            os << "(";
            for (const T &symbol: pattern.symbols) {
                if (!first) {
                    os << ", ";
                }
                else {
                    first = false;
                }
                os << "{" << symbol << "}";
            }
            os << ")";
            return os;
        }
 
    private:
        std::set<T> symbols{};
        bool neg = false;
    };
 
    template <typename KeyType, typename ValueType, typename SymbolType>
    class DynamicSymbolPattern : public SymbolPattern<SymbolType, std::map<KeyType, ValueType>> {
    public:
        constexpr explicit DynamicSymbolPattern(bool neg) : neg(neg) {}
 
        constexpr DynamicSymbolPattern(const KeyType& key) : keys({key}) {}
 
        constexpr DynamicSymbolPattern(const std::set<KeyType>& keys) : keys(keys) {}
 
        constexpr DynamicSymbolPattern(const std::set<KeyType>& keys, bool neg) : keys(keys), neg(neg) {}
 
        constexpr bool matchAccordingToPredicate(const std::map<KeyType, ValueType>& context, const std::function<bool(const ValueType&)>& predicate) const {
            for(const KeyType& key : keys) {
                typename std::map<KeyType, ValueType>::const_iterator it = context.find(key);
                if(it != context.end()) {
                    if(predicate(it->second)) {
                        return !neg;
                    }
                }
            }
            return neg;
        }
 
        constexpr bool operator==(const DynamicSymbolPattern<KeyType, ValueType, SymbolType>& other) const { return neg == other.neg && keys == other.keys; }
 
        constexpr bool operator!=(const DynamicSymbolPattern<KeyType, ValueType, SymbolType>& other) const { return neg != other.neg || keys != other.keys; }
 
        constexpr bool operator<(const DynamicSymbolPattern<KeyType, ValueType, SymbolType>& other) const {
            if(neg < other.neg) {
                return true;
            }
            if(neg > other.neg) {
                return false;
            }
            return keys < other.keys;
        }
 
        constexpr bool isAlphaEquivalent(const DynamicSymbolPattern<KeyType, ValueType, SymbolType>& other, const std::map<KeyType, KeyType>& rewriting) const {
            if(neg != other.neg) {
                return false;
            }
            if(keys.size() != other.keys.size()) {
                return false;
            }
            for(const KeyType& key : keys) {
                typename std::map<KeyType, KeyType>::const_iterator it = rewriting.find(key);
                if(it == rewriting.end()) {
                    return false;
                }
                if(other.keys.find(it->second) == other.keys.end()) {
                    return false;
                }
            }
            return true;
        }
 
        template <typename CharT = char, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const DynamicSymbolPattern<KeyType, ValueType, SymbolType>& pattern) {
            using Utils::Debug::operator<<;
            os << "dyn";
            if(pattern.neg) {
                os << "_non";
            }
            os << "(" << Utils::Debug::debug(pattern.keys) << ")";
            return os;
        }
 
    private:
        std::set<KeyType> keys{};
        bool neg = false;
    };
 
    template <typename SymbolType>
    class TuringStyleDynamicSymbolPattern : public DynamicSymbolPattern<SymbolType, State::MConfiguration::MConfiguration<SymbolType>, SymbolType> {
        typedef DynamicSymbolPattern<SymbolType, State::MConfiguration::MConfiguration<SymbolType>, SymbolType> DynamicSymbolPattern_;
    public:
        constexpr explicit TuringStyleDynamicSymbolPattern(bool neg) : DynamicSymbolPattern_(neg) {}
 
        constexpr TuringStyleDynamicSymbolPattern(const SymbolType& key) : DynamicSymbolPattern_({key}) {}
 
        constexpr TuringStyleDynamicSymbolPattern(const std::set<SymbolType>& keys) : DynamicSymbolPattern_(keys) {}
 
        constexpr TuringStyleDynamicSymbolPattern(const std::set<SymbolType>& keys, bool neg) : DynamicSymbolPattern_(keys, neg) {}
 
        virtual bool match(const SymbolType& symbol, const std::map<SymbolType, State::MConfiguration::MConfiguration<SymbolType>>& context) const override {
            std::function<bool(const State::MConfiguration::MConfiguration<SymbolType>&)> predicate =
                    [&symbol](const State::MConfiguration::MConfiguration<SymbolType>& m_conf) -> bool {
                        return m_conf.isLeaf() && m_conf.getNode() == symbol;
                    };
            return DynamicSymbolPattern_::matchAccordingToPredicate(context, predicate);
        }
 
        constexpr bool operator==(const TuringStyleDynamicSymbolPattern<SymbolType>& other) const { return DynamicSymbolPattern_::operator==(other); }
 
        constexpr bool operator!=(const TuringStyleDynamicSymbolPattern<SymbolType>& other) const { return DynamicSymbolPattern_::operator!=(other); }
 
        constexpr bool operator<(const TuringStyleDynamicSymbolPattern<SymbolType>& other) const { return DynamicSymbolPattern_::operator<(other); }
    };
 
    template <typename KeyType, typename ValueType, typename SymbolType>
    class MixedSymbolPattern : public SymbolPattern<SymbolType, std::map<KeyType, ValueType>> {
    public:
        constexpr MixedSymbolPattern(const std::set<KeyType>& symbols, const std::set<KeyType>& keys, bool neg) : symbols(symbols), keys(keys), neg(neg) {}
 
        constexpr bool matchAccordingToPredicate(const SymbolType& symbol, const std::map<KeyType, ValueType>& context, const std::function<bool(const ValueType&)>& predicate) const {
            if(!neg && symbols.find(symbol) != symbols.end()) {
                return true;
            }
            if(neg && symbols.find(symbol) != symbols.end()) {
                return false;
            }
            for(const KeyType& key : keys) {
                typename std::map<KeyType, ValueType>::const_iterator it = context.find(key);
                if(it != context.end()) {
                    if(predicate(it->second)) {
                        return !neg;
                    }
                }
            }
            return neg;
        }
 
        constexpr bool operator==(const MixedSymbolPattern<KeyType, ValueType, SymbolType>& other) const { return neg == other.neg && symbols == other.symbols && keys == other.keys; }
        constexpr bool operator!=(const MixedSymbolPattern<KeyType, ValueType, SymbolType>& other) const { return neg != other.neg || symbols != other.symbols || keys != other.keys; }
        constexpr bool operator<(const MixedSymbolPattern<KeyType, ValueType, SymbolType>& other) const {
            if(neg < other.neg) {
                return true;
            }
            if(neg > other.neg) {
                return false;
            }
            if(symbols < other.symbols) {
                return true;
            }
            if(symbols > other.symbols) {
                return false;
            }
            return keys < other.keys;
        }
 
        constexpr bool isAlphaEquivalent(const MixedSymbolPattern<KeyType, ValueType, SymbolType>& other, const std::map<KeyType, KeyType>& rewriting) const {
            if(neg != other.neg) {
                return false;
            }
            if(symbols != other.symbols) {
                return false;
            }
            if(keys.size() != other.keys.size()) {
                return false;
            }
            for(const KeyType& key : keys) {
                typename std::map<KeyType, KeyType>::const_iterator it = rewriting.find(key);
                if(it == rewriting.end()) {
                    return false;
                }
                if(other.keys.find(it->second) == other.keys.end()) {
                    return false;
                }
            }
            return true;
        }
 
        template <typename CharT = char, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const MixedSymbolPattern<KeyType, ValueType, SymbolType>& pattern) {
            using Utils::Debug::operator<<;
            os << "mixed";
            if(pattern.neg) {
                os << "_non";
            }
            os << "(" << Utils::Debug::debug(pattern.symbols) << ", " << Utils::Debug::debug(pattern.keys) << ")";
            return os;
        }
 
    private:
        std::set<SymbolType> symbols{};
        std::set<KeyType> keys{};
        bool neg = false;
    };
 
    template <typename SymbolType>
    class TuringStyleMixedSymbolPattern : public MixedSymbolPattern<SymbolType, std::shared_ptr<const State::MConfiguration::MConfiguration<SymbolType>>, SymbolType> {
        typedef MixedSymbolPattern<SymbolType, std::shared_ptr<const State::MConfiguration::MConfiguration<SymbolType>>, SymbolType> MixedSymbolPattern_;
    public:
        constexpr TuringStyleMixedSymbolPattern(const std::set<SymbolType>& symbols, const std::set<SymbolType>& keys, bool neg) :
                MixedSymbolPattern_(symbols, keys, neg)
        {}
 
        virtual bool match(const SymbolType& symbol, const std::map<SymbolType, std::shared_ptr<const State::MConfiguration::MConfiguration<SymbolType>>>& context) const noexcept override {
            std::function<bool(const std::shared_ptr<const State::MConfiguration::MConfiguration<SymbolType>>&)> predicate =
                    [&symbol](const std::shared_ptr<const State::MConfiguration::MConfiguration<SymbolType>>& m_conf) -> bool {
                        return m_conf->isLeaf() && m_conf->getNode() == symbol;
                    };
            return MixedSymbolPattern_::matchAccordingToPredicate(symbol, context, predicate);
        }
 
        constexpr bool operator==(const TuringStyleMixedSymbolPattern<SymbolType>& other) const { return MixedSymbolPattern_::operator==(other); }
 
        constexpr bool operator!=(const TuringStyleMixedSymbolPattern<SymbolType>& other) const { return MixedSymbolPattern_::operator!=(other); }
 
        constexpr bool operator<(const TuringStyleMixedSymbolPattern<SymbolType>& other) const { return MixedSymbolPattern_::operator<(other); }
    };
 
    template<typename T>
    using TuringStyleSymbolPattern = std::variant<TuringStyleConstantSymbolPattern<T>, TuringStyleDynamicSymbolPattern<T>>;
 
    template<typename T, typename CharT = char, typename Traits = std::char_traits<CharT>>
    std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits> &os, const TuringStyleSymbolPattern<T>& pattern) {
        using Utils::Visitor;
        std::visit(
                Visitor{
                        [&os](const TuringStyleConstantSymbolPattern<T> &p) { os << p; },
                        [&os](const TuringStyleDynamicSymbolPattern<T> &p) { os << p; },
                },
                pattern);
        return os;
    }
}