turingStyleMConfigurationTuringMachine.h

#pragma once
 
#include <variant>
 
#include <machine/Turing/localTuringMachine.h>
#include <state/mConfiguration/mConfigurationMap.h>
#include <transition/Turing/turingStyleMConfigurationTuringMachineTransition.h>
 
namespace TuringSim::Machine::Turing {
    template <
            typename SymbolType_,
            bool deterministic = false,
            bool hasHalfTape = false,
            AcceptingStyle acceptingStyle = AcceptingStyle::NonAccepting
    >
    class TuringStyleMConfigurationTuringMachine :
            public LocalTuringMachine<
                    Transition::Turing::TuringStyleMConfigurationTuringMachineTransition<SymbolType_, hasHalfTape>,
                    deterministic,
                    acceptingStyle,
                    std::set,
                    std::set
            >
    {
        typedef Transition::Turing::TuringStyleMConfigurationTuringMachineTransition<SymbolType_, hasHalfTape> TransitionType_;
        typedef LocalTuringMachine<TransitionType_, deterministic, acceptingStyle, std::set, std::set> LocalTuringMachine_;
    public:
        using typename LocalTuringMachine_::StateType;
        using typename LocalTuringMachine_::SymbolType;
        using typename LocalTuringMachine_::HasHalfTape;
        using typename LocalTuringMachine_::IsAccepting;
        using typename LocalTuringMachine_::StorageType;
        using typename LocalTuringMachine_::IsAlternating;
        using typename LocalTuringMachine_::TransitionType;
        using typename LocalTuringMachine_::ApplyHelperType;
        using typename LocalTuringMachine_::IsDeterministic;
        using typename LocalTuringMachine_::TransitionContainer;
        using typename LocalTuringMachine_::InitialStateContainer;
        using typename LocalTuringMachine_::OptionalHelpedTransition;
 
        static_assert(std::is_same_v<StateType, typename TransitionType::StateType>);
        static_assert(std::is_same_v<SymbolType, typename StorageType::SymbolType>);
        static_assert(std::is_same_v<SymbolType, SymbolType_>);
        static_assert(std::is_same_v<HasHalfTape, typename TransitionType::HasHalfTape>);
        static_assert(HasHalfTape::value == hasHalfTape);
        static_assert(std::is_same_v<StorageType, Memory::TapeLike<hasHalfTape, SymbolType>>);
        static_assert(std::is_same_v<StorageType, typename TransitionType::StorageType>);
        static_assert(std::is_same_v<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(IsDeterministic::value == deterministic);
        static_assert(std::is_same_v<TransitionContainer, std::set<std::pair<const TransitionType&, ApplyHelperType>>>);
        static_assert(std::is_same_v<InitialStateContainer, std::set<StateType>>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType&, ApplyHelperType>>>);
 
        static_assert(std::is_same_v<StateType, std::shared_ptr<const State::MConfiguration::MConfiguration<SymbolType>>>,
                      "StateType must be std::shared_ptr<State::MConfiguration<SymbolType>>");
        static_assert(std::is_same_v<TransitionType, Transition::Turing::TuringStyleMConfigurationTuringMachineTransition<SymbolType_, hasHalfTape>>,
                      "TransitionType must be a TuringStyleMConfigurationTuringMachineTransition");
 
        TuringStyleMConfigurationTuringMachine() = delete;
        TuringStyleMConfigurationTuringMachine(const TuringStyleMConfigurationTuringMachine&) = default;
        TuringStyleMConfigurationTuringMachine(TuringStyleMConfigurationTuringMachine&&) = default;
        TuringStyleMConfigurationTuringMachine& operator=(const TuringStyleMConfigurationTuringMachine&) = default;
        TuringStyleMConfigurationTuringMachine& operator=(TuringStyleMConfigurationTuringMachine&&) = default;
        virtual ~TuringStyleMConfigurationTuringMachine() override = default;
 
        TuringStyleMConfigurationTuringMachine(
                const std::set<State::MConfiguration::MConfiguration<SymbolType>>& finalStates
        ) :
                finalStates(finalStates)
        {}
 
        virtual bool isHaltingState(const StateType& state) const noexcept override final {
            return finalStates.count(*state) > 0;
        }
 
    private:
        std::set<State::MConfiguration::MConfiguration<SymbolType>> finalStates;
    };
}