deterministicMachineRunner.h

#pragma once
 
#include <runner/machineRunner.h>
 
namespace TuringSim::Runner {
    template<
            typename MachineType,
            typename ListenerType,
            typename ListenerConstructorArgs = typename MachineRunnerArgs<MachineType, ListenerType>::ListenerConstructorArgs
    >
    class DeterministicMachineRunner;
 
    template<
            typename MachineType_,
            typename ListenerType_,
            typename... Args
    >
    class DeterministicMachineRunner<
            MachineType_,
            ListenerType_,
            std::tuple<Args...>
    >
            : 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 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, ListenerIdType>, StateType> StateAndIdType;
 
        static_assert(std::is_same_v<std::tuple<Args...>, typename MachineRunnerArgs<MachineType, ListenerType>::ListenerConstructorArgs>,
                      "The only valid value of template parameter ListenerConstructorArgs is the default one.");
 
        DeterministicMachineRunner(const MachineType& machine, Args ...listener) :
                MachineRunner_(machine, listener...),
                currentStateAndId(getInitialStateAndId()),
                memory(),
                running(true) {
        }
 
        constexpr DeterministicMachineRunner(const DeterministicMachineRunner& other) :
                MachineRunner_(other),
                currentStateAndId(other.currentStateAndId),
                memory(other.memory),
                running(other.running)
        {}
 
        constexpr DeterministicMachineRunner(DeterministicMachineRunner&& other) :
                MachineRunner_(std::move(other)),
                currentStateAndId(std::move(other.currentStateAndId)),
                memory(std::move(other.memory)),
                running(std::move(other.running))
        {}
 
        constexpr DeterministicMachineRunner& operator=(const DeterministicMachineRunner& other) {
            if(this != &other) {
                MachineRunner_::operator=(other);
                currentStateAndId = other.currentStateAndId;
                memory = other.memory;
                running = other.running;
            }
            return *this;
        }
 
        constexpr DeterministicMachineRunner& operator=(DeterministicMachineRunner&& other) {
            if(this != &other) {
                MachineRunner_::operator=(std::move(other));
                currentStateAndId = std::move(other.currentStateAndId);
                memory = std::move(other.memory);
                running = std::move(other.running);
            }
            return *this;
        }
 
        virtual ~DeterministicMachineRunner() override {}
 
        const StorageType& getStorage() const noexcept {
            return memory;
        }
 
        StorageType& getStorage() noexcept {
            return memory;
        }
 
        const StateType& getCurrentState() const noexcept {
            if constexpr (IsListened_v) {
                return std::get<StateType>(currentStateAndId);
            } else {
                return currentStateAndId;
            }
        }
 
        bool isRunning() const noexcept {
            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();
            }
        }
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
 
        virtual bool accept() {
            this->exec();
 
            if constexpr (!IsAccepting_v) {
                return true;
            }
            else if constexpr (IsAccepting_v && !IsAlternating_v) {
                return this->machine.isAcceptingConfiguration(getCurrentState(), this->getStorage());
            } else {
                switch (this->machine.isAcceptingConfiguration(getCurrentState(), memory)) {
                    case Machine::Acceptance::Accept:
                    case Machine::Acceptance::Universal:
                        return true;
                    case Machine::Acceptance::Reject:
                    case Machine::Acceptance::Existential:
                        return false;
                }
            }
        }
#pragma clang diagnostic pop
 
    protected:
        StateAndIdType getInitialStateAndId() {
            if constexpr (IsListened_v) {
                return {MachineRunner_::machine.getInitialState(), MachineRunner_::listener.getInitialId()};
            } else {
                return MachineRunner_::machine.getInitialState();
            }
        }
 
        virtual void oneStep() override {
            if (!this->running) {
                return;
            }
 
            if constexpr (IsListened_v) {
                auto& [currentState, currentId] = currentStateAndId;
                std::optional<std::pair<const TransitionType &, ApplyHelperType>> matchingTransition =
                        MachineRunner_::machine.getMatchingTransition(currentState, memory);
 
                if (matchingTransition) {
                    ListenerIdType id = this->listener.registerPreTransition(currentState, memory, currentId);
                    auto&[transition, helper] = *matchingTransition;
                    currentState = transition.apply(
                            currentState,
                            memory,
                            std::move(helper),
                            this->running);
                    this->running = this->running && !this->machine.isHaltingConfiguration(currentState, memory);
                    this->listener.registerPostTransition(id, currentState, memory, transition, helper, this->running);
                    currentId = id;
                } else {
                    this->running = false;
                    this->listener.registerNoTransition(currentId, currentState, memory);
                }
            } else {
                auto& currentState = currentStateAndId;
                std::optional<std::pair<const TransitionType &, ApplyHelperType>> matchingTransition =
                        MachineRunner_::machine.getMatchingTransition(currentState, memory);
 
                if (matchingTransition) {
                    auto&[transition, helper] = *matchingTransition;
                    currentState = transition.apply(
                            currentState,
                            memory,
                            std::move(helper),
                            this->running);
                    this->running = this->running && !this->machine.isHaltingConfiguration(currentState, memory);
                } else {
                    this->running = false;
                }
            }
        }
 
        StateAndIdType currentStateAndId;
 
        StorageType memory;
 
        bool running;
    };
}