machine.h

#pragma once
 
#include <transition/transition.h>
#include <machine/acceptingMachine.h>
 
namespace TuringSim::Machine {
    template <
            typename TransitionType,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer = std::vector,
            template <typename...> class InitialStateContainer = std::vector
    >
    class Machine;
 
    template <
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_
    >
    class Machine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> :
            public AcceptingMachine<TransitionType_, acceptingStyle> {
    public:
        typedef TransitionType_ TransitionType;
 
        typedef typename TransitionType::StateType StateType;
 
        typedef typename TransitionType::StorageType StorageType;
 
        typedef typename TransitionType::ApplyHelperType ApplyHelperType;
 
        typedef TransitionContainer_<std::pair<const TransitionType&, ApplyHelperType>> TransitionContainer;
 
        typedef std::optional<std::pair<const TransitionType&, ApplyHelperType>> OptionalHelpedTransition;
 
        typedef InitialStateContainer_<StateType> InitialStateContainer;
 
        typedef std::false_type IsDeterministic;
 
        static_assert(std::is_base_of_v<Transition::Transition<StateType, StorageType, ApplyHelperType>, TransitionType>,
                      "TransitionType must be a derived class from Transition::Transition<StateType, StorageType, ApplyHelperType>.");
 
        Machine() = default;
 
        Machine(const Machine&) = default;
 
        Machine(Machine&&) = default;
 
        Machine& operator=(const Machine&) = default;
 
        Machine& operator=(Machine&&) = default;
 
        virtual ~Machine() = default;
 
        virtual InitialStateContainer getInitialStates() const noexcept = 0;
 
        virtual TransitionContainer getMatchingTransitions(const StateType& state, const StorageType& storage) const noexcept = 0;
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept = 0;
    };
 
    template <
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_
    >
    class Machine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_> :
            public AcceptingMachine<TransitionType_, acceptingStyle> {
        typedef AcceptingMachine<TransitionType_, acceptingStyle> AcceptingMachine_;
    public:
        using typename AcceptingMachine_::IsAccepting;
        using typename AcceptingMachine_::IsAlternating;
 
        typedef TransitionType_ TransitionType;
        typedef typename TransitionType::StateType StateType;
        typedef typename TransitionType::StorageType StorageType;
        typedef typename TransitionType::ApplyHelperType ApplyHelperType;
        typedef TransitionContainer_<std::pair<const TransitionType&, ApplyHelperType>> TransitionContainer;
        typedef std::optional<std::pair<const TransitionType&, ApplyHelperType>> OptionalHelpedTransition;
        typedef InitialStateContainer_<StateType> InitialStateContainer;
        typedef std::true_type IsDeterministic;
 
        static_assert(std::is_base_of_v<Transition::Transition<StateType, StorageType, ApplyHelperType>, TransitionType>,
                      "TransitionType must be a derived class from Transition::Transition<StateType, StorageType, ApplyHelperType>.");
 
        Machine() = default;
        Machine(const Machine&) = default;
        Machine(Machine&&) = default;
        Machine& operator=(const Machine&) = default;
        Machine& operator=(Machine&&) = default;
        virtual ~Machine() = default;
 
        virtual StateType getInitialState() const noexcept = 0;
 
        virtual InitialStateContainer getInitialStates() const noexcept final {
            return InitialStateContainer{this->getInitialState()};
        }
 
        virtual OptionalHelpedTransition getMatchingTransition(const StateType& state, const StorageType& storage) const noexcept = 0;
 
        virtual TransitionContainer getMatchingTransitions(const StateType& state, const StorageType& storage) const noexcept final {
            std::optional<std::pair<TransitionType, ApplyHelperType>> transition = this->getMatchingTransition(state, storage);
            if(transition) {
                return TransitionContainer {{*transition}};
            }
            return TransitionContainer {};
        }
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept = 0;
    };
}