machineRunner.h

#pragma once
 
#include <machine/machine.h>
#include <listener/listener.h>
 
namespace TuringSim::Runner {
    template<typename MachineType, typename Enable = void>
    class MachineRunner_accepting_impl;
 
    template<typename MachineType_>
    class MachineRunner_accepting_impl<MachineType_, std::enable_if_t<!MachineType_::IsAccepting::value>> {
    public:
        MachineRunner_accepting_impl() = default;
 
        MachineRunner_accepting_impl(const MachineRunner_accepting_impl&) = default;
 
        MachineRunner_accepting_impl(MachineRunner_accepting_impl&&) = default;
 
        MachineRunner_accepting_impl& operator=(const MachineRunner_accepting_impl&) = default;
 
        MachineRunner_accepting_impl& operator=(MachineRunner_accepting_impl&&) = default;
 
        virtual ~MachineRunner_accepting_impl() = default;
    };
 
    template<typename MachineType_>
    class MachineRunner_accepting_impl<MachineType_, std::enable_if_t<MachineType_::IsAccepting::value>> {
    public:
        MachineRunner_accepting_impl() = default;
 
        MachineRunner_accepting_impl(const MachineRunner_accepting_impl&) = default;
 
        MachineRunner_accepting_impl(MachineRunner_accepting_impl&&) = default;
 
        MachineRunner_accepting_impl& operator=(const MachineRunner_accepting_impl&) = default;
 
        MachineRunner_accepting_impl& operator=(MachineRunner_accepting_impl&&) = default;
 
        virtual ~MachineRunner_accepting_impl() = default;
 
        virtual bool accept() = 0;
    };
 
    template <typename MachineType, typename ListenerType>
    struct MachineRunnerArgs {
        typedef std::tuple<const MachineType&, ListenerType&> ConstructorArgs;
        typedef std::tuple<ListenerType&> ListenerConstructorArgs;
    };
 
    template <typename MachineType>
    struct MachineRunnerArgs<MachineType, void> {
        typedef std::tuple<const MachineType&> ConstructorArgs;
        typedef std::tuple<> ListenerConstructorArgs;
    };
 
    template <typename MachineType_, typename ListenerType_>
    class MachineRunner : public MachineRunner_accepting_impl<MachineType_> {
    public:
        typedef MachineType_ MachineType;
 
        typedef ListenerType_ ListenerType;
 
 
        typedef typename MachineType::StateType StateType;
 
        typedef typename MachineType::StorageType StorageType;
 
        typedef typename MachineType::TransitionType TransitionType;
 
        typedef typename MachineType::ApplyHelperType ApplyHelperType;
 
 
        typedef typename ListenerType::IdType ListenerIdType;
 
        static_assert(std::is_same_v<typename ListenerType::MachineType, MachineType>,
                      "The listener must be made for the same machine type as the runner.");
        static_assert(std::is_base_of_v<Listener::Listener<MachineType, ListenerIdType>, ListenerType>,
                      "The listener must be a derived class of TuringSim::Runner::Listener");
 
        MachineRunner(const MachineType& machine, ListenerType& listener) :
                machine(machine),
                listener(listener)
        {}
 
        constexpr MachineRunner(const MachineRunner& other) = default;
 
        constexpr MachineRunner(MachineRunner&& other) = default;
 
        constexpr MachineRunner& operator=(const MachineRunner& other) = default;
 
        constexpr MachineRunner& operator=(MachineRunner&& other) = default;
 
        virtual ~MachineRunner() override = default;
 
        virtual void step(size_t nbIter = 1) = 0;
 
        virtual void exec() = 0;
 
    protected:
        virtual void oneStep() = 0;
 
        const MachineType& machine;
 
        ListenerType& listener;
    };
 
    template <typename MachineType_>
    class MachineRunner<MachineType_, void> : public MachineRunner_accepting_impl<MachineType_> {
    public:
        typedef MachineType_ MachineType;
 
        typedef void ListenerType;
 
        typedef void ListenerIdType;
 
 
        typedef typename MachineType::StateType StateType;
 
        typedef typename MachineType::StorageType StorageType;
 
        typedef typename MachineType::TransitionType TransitionType;
 
        typedef typename MachineType::ApplyHelperType ApplyHelperType;
 
 
        MachineRunner(const MachineType& machine) :
                machine(machine)
        {}
 
        constexpr MachineRunner(const MachineRunner& other) = default;
 
        constexpr MachineRunner(MachineRunner&& other) = default;
        constexpr MachineRunner& operator=(const MachineRunner& other) = default;
 
        constexpr MachineRunner& operator=(MachineRunner&& other) = default;
 
        virtual ~MachineRunner() override = default;
 
        virtual void step(size_t nbIter = 1) = 0;
 
        virtual void exec() = 0;
 
    protected:
        virtual void oneStep() = 0;
 
        const MachineType& machine;
    };
 
}