localTuringMachine.h

#pragma once
 
#include <variant>
 
#include <machine/Turing/turingMachine.h>
#include <transition/Turing/localTuringMachineTransition.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 LocalTuringMachine;
 
    template<
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_>
    class LocalTuringMachine<
            TransitionType_,
            false,
            acceptingStyle,
            TransitionContainer_,
            InitialStateContainer_> :
            public TuringMachine<
                    TransitionType_,
                    false,
                    acceptingStyle,
                    TransitionContainer_,
                    InitialStateContainer_> {
        typedef TuringMachine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> TuringMachine_;
    public:
        using typename TuringMachine_::StateType;
        using typename TuringMachine_::SymbolType;
        using typename TuringMachine_::HasHalfTape;
        using typename TuringMachine_::IsAccepting;
        using typename TuringMachine_::StorageType;
        using typename TuringMachine_::IsAlternating;
        using typename TuringMachine_::TransitionType;
        using typename TuringMachine_::ApplyHelperType;
        using typename TuringMachine_::IsDeterministic;
        using typename TuringMachine_::TransitionContainer;
        using typename TuringMachine_::InitialStateContainer;
        using typename TuringMachine_::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<HasHalfTape, typename TransitionType::HasHalfTape>);
        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::false_type>);
        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_base_of_v<Transition::Turing::LocalTuringMachineTransition<StateType, SymbolType, ApplyHelperType, HasHalfTape::value>, TransitionType>,
                      "TransitionType must be a derived class of LocalTuringMachineTransition");
 
        LocalTuringMachine() = default;
        LocalTuringMachine(const LocalTuringMachine&) = default;
        LocalTuringMachine(LocalTuringMachine&&) = default;
        LocalTuringMachine& operator=(const LocalTuringMachine&) = default;
        LocalTuringMachine& operator=(LocalTuringMachine&&) = default;
        virtual ~LocalTuringMachine() override = default;
 
        virtual TransitionContainer getMatchingTransitionsFromCurrentCell(const StateType& state, const SymbolType& symbol) const noexcept = 0;
 
        virtual TransitionContainer getMatchingTransitions(const StateType& state, const StorageType& tape) const noexcept override final {
            return this->getMatchingTransitionsFromCurrentCell(state, tape.read());
        }
    };
 
    template<
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_>
    class LocalTuringMachine<
            TransitionType_,
            true,
            acceptingStyle,
            TransitionContainer_,
            InitialStateContainer_> :
            public TuringMachine<
                    TransitionType_,
                    true,
                    acceptingStyle,
                    TransitionContainer_,
                    InitialStateContainer_> {
        typedef TuringMachine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_> TuringMachine_;
    public:
        using typename TuringMachine_::StateType;
        using typename TuringMachine_::SymbolType;
        using typename TuringMachine_::HasHalfTape;
        using typename TuringMachine_::IsAccepting;
        using typename TuringMachine_::StorageType;
        using typename TuringMachine_::IsAlternating;
        using typename TuringMachine_::TransitionType;
        using typename TuringMachine_::ApplyHelperType;
        using typename TuringMachine_::IsDeterministic;
        using typename TuringMachine_::TransitionContainer;
        using typename TuringMachine_::InitialStateContainer;
        using typename TuringMachine_::OptionalHelpedTransition;
 
        static_assert(std::is_same_v<StateType, typename TransitionType::StateType>);
        static_assert(std::is_same_v<HasHalfTape, typename TransitionType::HasHalfTape>);
        static_assert(std::is_same_v<SymbolType, typename StorageType::SymbolType>);
        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::true_type>);
        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_base_of_v<Transition::Turing::LocalTuringMachineTransition<StateType, SymbolType, ApplyHelperType, HasHalfTape::value>, TransitionType>,
                      "TransitionType must be a derived class of LocalTuringMachineTransition");
 
        LocalTuringMachine() = default;
        LocalTuringMachine(const LocalTuringMachine&) = default;
        LocalTuringMachine(LocalTuringMachine&&) = default;
        LocalTuringMachine& operator=(const LocalTuringMachine&) = default;
        LocalTuringMachine& operator=(LocalTuringMachine&&) = default;
        virtual ~LocalTuringMachine() override = default;
 
        virtual OptionalHelpedTransition getMatchingTransitionFromCurrentCell(const StateType& state, const SymbolType& symbol) const noexcept = 0;
 
        virtual OptionalHelpedTransition getMatchingTransition(const StateType& state, const StorageType& tape) const noexcept override final {
            return this->getMatchingTransitionFromCurrentCell(state, tape.read());
        }
    };
}