simpleTuringMachine.h

#pragma once
 
#include <map>
#include <variant>
 
#include <machine/Turing/localTuringMachine.h>
#include <transition/Turing/simpleTuringMachineTransition.h>
 
namespace TuringSim::Machine::Turing {
    template<
            typename StateType_,
            typename SymbolType_,
            bool deterministic = false,
            bool hasHalfTape = false,
            AcceptingStyle acceptingStyle = AcceptingStyle::NonAccepting
    >
    class SimpleTuringMachine :
            public LocalTuringMachine<
                    Transition::Turing::SimpleTuringMachineTransition<StateType_, SymbolType_, hasHalfTape>,
                    deterministic,
                    acceptingStyle,
                    std::set,
                    std::set> {
        typedef typename Transition::Turing::SimpleTuringMachineTransition<StateType_, 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<StateType, 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<ApplyHelperType, std::monostate>);
        static_assert(std::is_same_v<Transition::Turing::SimpleTuringMachineTransition<StateType, SymbolType, HasHalfTape::value>, TransitionType>,
                      "TransitionType must be SimpleTuringMachineTransition");
 
        SimpleTuringMachine() = delete;
        SimpleTuringMachine(const SimpleTuringMachine&) = default;
        SimpleTuringMachine(SimpleTuringMachine&&) = default;
        SimpleTuringMachine& operator=(const SimpleTuringMachine&) = default;
        SimpleTuringMachine& operator=(SimpleTuringMachine&&) = default;
        virtual ~SimpleTuringMachine() override = default;
 
        SimpleTuringMachine(const std::set<StateType>& finalStates) : finalStates(finalStates) {}
 
        virtual bool isHaltingState(const StateType& state) const noexcept override final {
            return finalStates.count(state) > 0;
        }
 
    private:
        std::set<StateType> finalStates;
    };
}