turingMachine.h

#pragma once
 
#include <memory/tapeLike.h>
#include <machine/machine.h>
#include <transition/Turing/turingMachineTransition.h>
 
namespace TuringSim::Machine::Turing {
    template <
            typename TransitionType_,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_ = std::vector,
            template <typename...> class InitialStateContainer_ = std::vector>
    class TuringMachine : public Machine<TransitionType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_>
    {
        typedef Machine<TransitionType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_> Machine_;
    public:
        using typename Machine_::StateType;
        using typename Machine_::IsAccepting;
        using typename Machine_::StorageType;
        using typename Machine_::IsAlternating;
        using typename Machine_::TransitionType;
        using typename Machine_::ApplyHelperType;
        using typename Machine_::IsDeterministic;
        using typename Machine_::TransitionContainer;
        using typename Machine_::InitialStateContainer;
        using typename Machine_::OptionalHelpedTransition;
 
        typedef typename StorageType::SymbolType SymbolType;
 
        typedef typename TransitionType::HasHalfTape HasHalfTape;
 
        static_assert(std::is_same_v<StateType, typename TransitionType::StateType>);
        static_assert(std::is_same_v<StorageType, typename TransitionType::StorageType>);
        static_assert(std::is_same_v<TransitionType, TransitionType_>);
        static_assert(std::is_same_v<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(std::is_same_v<IsDeterministic, std::integral_constant<bool, deterministic>>);
        static_assert(std::is_same_v<TransitionContainer, TransitionContainer_<std::pair<const TransitionType&, ApplyHelperType>>>);
        static_assert(std::is_same_v<InitialStateContainer, InitialStateContainer_<StateType>>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType&, ApplyHelperType>>>);
 
        static_assert(std::is_same_v<StorageType, Memory::TapeLike<HasHalfTape::value, SymbolType>>,
                      "StorageType should be TapeLike.");
        static_assert(std::is_base_of_v<Transition::Turing::TuringMachineTransition<StateType, SymbolType, ApplyHelperType, HasHalfTape::value>, TransitionType>,
                      "TransitionType must be a derived class of TuringMachineTransition");
 
        TuringMachine() = default;
        TuringMachine(const TuringMachine&) = default;
        TuringMachine(TuringMachine&&) = default;
        TuringMachine& operator=(const TuringMachine&) = default;
        TuringMachine& operator=(TuringMachine&&) = default;
        virtual ~TuringMachine() override = default;
 
        virtual bool isHaltingState(const StateType& state) const noexcept = 0;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            return this->isHaltingState(state);
        }
#pragma clang diagnostic pop
    };
}