maybeEpsilonFiniteStateMachineRunner.h

#pragma once
 
#include <memory/word.h>
#include <runner/machineRunner.h>
#include <machine/FSM/maybeEpsilonFiniteStateMachine.h>
 
namespace TuringSim::Runner {
    template<
            typename MachineType,
            typename ListenerType,
            typename ListenerConstructorArgs = typename MachineRunnerArgs<MachineType, ListenerType>::ListenerConstructorArgs
    >
    class MaybeEpsilonFiniteStateMachineRunner;
 
    template<
            typename MachineType_,
            typename ListenerType_,
            typename... ListenerConstructorArgs
    >
    class MaybeEpsilonFiniteStateMachineRunner<
            MachineType_,
            ListenerType_,
            std::tuple<ListenerConstructorArgs...>
    >
            : public MachineRunner<MachineType_, ListenerType_> {
        typedef MachineRunner <MachineType_, ListenerType_> MachineRunner_;
    public:
        using typename MachineRunner_::StateType;
        using typename MachineRunner_::MachineType;
        using typename MachineRunner_::StorageType;
        using typename MachineRunner_::ListenerType;
        using typename MachineRunner_::ListenerIdType;
        using typename MachineRunner_::TransitionType;
        using typename MachineRunner_::ApplyHelperType;
 
        typedef typename MachineType::SymbolType SymbolType;
 
        typedef std::integral_constant<bool, !std::is_same_v<ListenerType, void>> IsListened;
        static constexpr bool IsListened_v = IsListened::value;
 
        typedef typename MachineType::IsAccepting IsAccepting;
        static constexpr bool IsAccepting_v = IsAccepting::value;
 
        typedef typename MachineType::IsAlternating IsAlternating;
        static constexpr bool IsAlternating_v = IsAlternating::value;
 
        typedef
        std::conditional_t<
                IsListened_v,
                std::tuple<StateType, size_t, ListenerIdType>,
                std::tuple<StateType, size_t>
        > ConfigurationType;
 
        static_assert(std::is_same_v<StorageType, Memory::Word::Word<SymbolType>>);
 
        static_assert(std::is_same_v<MachineType, Machine::FSM::MaybeEpsilonFiniteStateMachine<StateType, SymbolType>>,
                      "Machine must be a NonDeterministicSimpleFiniteStateMachine");
 
        static_assert(std::is_same_v<std::tuple<ListenerConstructorArgs...>, typename MachineRunnerArgs<MachineType, ListenerType>::ListenerConstructorArgs>,
                      "The only allowed value for ListenerConstructorArgs is the default one.");
 
        static_assert(IsAccepting_v, "The machine must be accepting.");
        static_assert(!IsAlternating_v, "The machine cannot be alternating.");
 
        MaybeEpsilonFiniteStateMachineRunner() = delete;
 
        MaybeEpsilonFiniteStateMachineRunner(const MachineType& machine, ListenerConstructorArgs... listener, const std::vector<SymbolType>& word) :
                MachineRunner_(machine, listener...),
                word(word),
                modifier(this->word),
                observer(this->word),
                currentConfigurations(),
                terminatedConfigurations(),
                running(true)
        {
            for(const StateType& state: machine.getInitialStates()) {
                if constexpr (IsListened_v) {
                    if (machine.isHaltingConfiguration(state, word)) {
                        terminatedConfigurations.insert({state, 0, MachineRunner_::listener.getInitialId()});
                    } else {
                        currentConfigurations.insert({state, 0, MachineRunner_::listener.getInitialId()});
                    }
                } else {
                    if (machine.isHaltingConfiguration(state, word)) {
                        terminatedConfigurations.insert({state, 0});
                    } else {
                        currentConfigurations.insert({state, 0});
                    }
                }
            }
        }
 
        constexpr MaybeEpsilonFiniteStateMachineRunner(const MaybeEpsilonFiniteStateMachineRunner& other) :
                MachineRunner_(other.machine, other.listener),
                word(other.word),
                modifier(this->word),
                observer(this->word),
                currentConfigurations(other.currentConfigurations),
                terminatedConfigurations(other.terminatedConfigurations),
                running(other.running)
        {}
 
        constexpr MaybeEpsilonFiniteStateMachineRunner(MaybeEpsilonFiniteStateMachineRunner&& other) = default;
 
        constexpr MaybeEpsilonFiniteStateMachineRunner& operator=(const MaybeEpsilonFiniteStateMachineRunner& other) {
            if(this != &other) {
                MachineRunner_::operator=(other);
                word = other.word;
                observer = Memory::Word::Word<SymbolType>::Observer(word);
                modifier = Memory::Word::Word<SymbolType>::Modifier(word);
                currentConfigurations = other.currentConfigurations;
                terminatedConfigurations = other.terminatedConfigurations;
                running = other.running;
            }
            return *this;
        }
 
        constexpr MaybeEpsilonFiniteStateMachineRunner& operator=(MaybeEpsilonFiniteStateMachineRunner&& other) = default;
        virtual ~MaybeEpsilonFiniteStateMachineRunner() override = default;
 
        const StorageType& getWord() const {
            return word;
        }
 
        StorageType& getWord() {
            return word;
        }
 
        const std::set<ConfigurationType>& getCurrentConfigurations() const {
            return currentConfigurations;
        }
 
        const std::set<ConfigurationType>& getTerminatedConfigurations() const {
            return terminatedConfigurations;
        }
 
        bool isRunning() const {
            return running;
        }
 
        virtual void step(size_t nbIter = 1) override {
            for(size_t i = 0; i < nbIter && running; ++i) {
                this->oneStep();
            }
        }
 
        virtual void exec() override {
            while(running) {
                this->oneStep();
            }
        }
 
        virtual bool accept() override {
            exec();
            for (auto content: terminatedConfigurations) {
                if (MachineRunner_::machine.isAcceptingState(std::get<0>(content))) {
                    return true;
                }
            }
            return false;
        }
 
    protected:
        virtual void oneStep() override {
            if (!running) {
                return;
            }
 
            running = false;
 
            std::set<ConfigurationType> newStates;
 
            for(const auto& currentConfiguration: currentConfigurations) {
                if constexpr (IsListened_v) {
                    const auto&[currentState, position, currentId] = currentConfiguration;
                    modifier.setPosition(position);
                    std::set<std::pair<const TransitionType &, ApplyHelperType>> matchingTransitions =
                            MachineRunner_::machine.getMatchingTransitions(currentState, word);
 
                    if (matchingTransitions.empty()) {
                        MachineRunner_::listener.registerNoTransition(currentId, currentState, word);
                        terminatedConfigurations.insert({currentState, position, currentId});
                    } else {
                        for (auto[transition, helper]: matchingTransitions) {
                            ListenerIdType id = MachineRunner_::listener.registerPreTransition(currentState, word, currentId);
                            StateType newState = transition.apply(
                                    currentState,
                                    word,
                                    std::move(helper),
                                    running);
                            bool runningNewState = !MachineRunner_::machine.isHaltingConfiguration(newState, word);
                            MachineRunner_::listener.registerPostTransition(id, newState, word, transition, helper,
                                                                  runningNewState);
                            if (runningNewState) {
                                newStates.insert({newState, observer.getPosition(), id});
                                running = true;
                            } else {
                                terminatedConfigurations.insert({newState, observer.getPosition(), id});
                            }
                        }
                    }
                } else {
                    const auto&[currentState, position] = currentConfiguration;
                    modifier.setPosition(position);
                    std::set<std::pair<const TransitionType &, ApplyHelperType>> matchingTransitions =
                            MachineRunner_::machine.getMatchingTransitions(currentState, word);
 
                    if (matchingTransitions.empty()) {
                        terminatedConfigurations.insert({currentState, position});
                    } else {
                        for (auto[transition, helper]: matchingTransitions) {
 
                            StateType newState = transition.apply(
                                    currentState,
                                    word,
                                    std::move(helper),
                                    running);
                            bool runningNewState = !MachineRunner_::machine.isHaltingConfiguration(newState, word);
                            if (runningNewState) {
                                newStates.insert({newState, observer.getPosition()});
                                running = true;
                            } else {
                                terminatedConfigurations.insert({newState, observer.getPosition()});
                            }
                        }
                    }
                }
            }
            currentConfigurations = std::move(newStates);
        }
 
 
        Memory::Word::Word<SymbolType> word;
 
        typename Memory::Word::Word<SymbolType>::Modifier modifier;
 
        typename Memory::Word::Word<SymbolType>::Observer observer;
 
        std::set<ConfigurationType> currentConfigurations;
 
        std::set<ConfigurationType> terminatedConfigurations;
 
        bool running;
    };
}