deterministicTuringStyleMConfigurationTuringMachine.h

#pragma once
 
#include <machine/Turing/turingStyleMConfigurationTuringMachine.h>
 
namespace TuringSim::Machine::Turing {
    template <
            typename SymbolType_,
            bool hasHalfTape = false,
            AcceptingStyle acceptingStyle = AcceptingStyle::NonAccepting
    >
    class DeterministicTuringStyleMConfigurationTuringMachine : public TuringStyleMConfigurationTuringMachine<SymbolType_, true, hasHalfTape, acceptingStyle> {
        typedef TuringStyleMConfigurationTuringMachine<SymbolType_, true, hasHalfTape, acceptingStyle> TuringStyleMConfigurationTuringMachine_;
    public:
        using typename TuringStyleMConfigurationTuringMachine_::StateType;
        using typename TuringStyleMConfigurationTuringMachine_::SymbolType;
        using typename TuringStyleMConfigurationTuringMachine_::HasHalfTape;
        using typename TuringStyleMConfigurationTuringMachine_::IsAccepting;
        using typename TuringStyleMConfigurationTuringMachine_::StorageType;
        using typename TuringStyleMConfigurationTuringMachine_::IsAlternating;
        using typename TuringStyleMConfigurationTuringMachine_::TransitionType;
        using typename TuringStyleMConfigurationTuringMachine_::ApplyHelperType;
        using typename TuringStyleMConfigurationTuringMachine_::IsDeterministic;
        using typename TuringStyleMConfigurationTuringMachine_::TransitionContainer;
        using typename TuringStyleMConfigurationTuringMachine_::InitialStateContainer;
        using typename TuringStyleMConfigurationTuringMachine_::OptionalHelpedTransition;
 
        static_assert(std::is_same_v<StateType, typename TransitionType::StateType>);
        static_assert(std::is_same_v<StateType, std::shared_ptr<const State::MConfiguration::MConfiguration<SymbolType>>>);
        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<TransitionType, Transition::Turing::TuringStyleMConfigurationTuringMachineTransition<SymbolType_, hasHalfTape>>);
        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, 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>>>);
 
        DeterministicTuringStyleMConfigurationTuringMachine() = delete;
        DeterministicTuringStyleMConfigurationTuringMachine(const DeterministicTuringStyleMConfigurationTuringMachine&) = default;
        DeterministicTuringStyleMConfigurationTuringMachine(DeterministicTuringStyleMConfigurationTuringMachine&&) = default;
        DeterministicTuringStyleMConfigurationTuringMachine& operator=(const DeterministicTuringStyleMConfigurationTuringMachine&) = default;
        DeterministicTuringStyleMConfigurationTuringMachine& operator=(DeterministicTuringStyleMConfigurationTuringMachine&&) = default;
        virtual ~DeterministicTuringStyleMConfigurationTuringMachine() override = default;
 
        DeterministicTuringStyleMConfigurationTuringMachine(
                const StateType& initialState,
                const std::set<State::MConfiguration::MConfiguration<SymbolType>>& finalStates,
                const std::set<TransitionType>& transitions
        ) :
                TuringStyleMConfigurationTuringMachine_(finalStates),
                initialState(initialState),
                transitions()
        {
            for(const TransitionType& transition: transitions) {
                if(transition.getPreStatePattern()->isVariable()) {
                    this->pureVariablePreStatePatternTransitions.insert(transition);
                }
                else{
                    this->transitions.insert(*transition.getPreStatePattern(), transition);
                }
            }
        }
 
 
        virtual StateType getInitialState() const noexcept override final {
            return initialState;
        }
 
        virtual OptionalHelpedTransition getMatchingTransitionFromCurrentCell(const StateType& state, const SymbolType& symbol) const noexcept override final {
            try {
                const std::map<State::MConfiguration::MConfiguration<SymbolType>, std::set<TransitionType>>& candidates = transitions.getCandidates(*state);
                std::set<std::pair<const TransitionType&, ApplyHelperType>> matchingTransitions;
                for(const auto& [_pattern, transitions]: candidates) {
                    for(const TransitionType& transition: transitions) {
                        std::optional<ApplyHelperType> helper = transition.matchFromCurrentCell(state, symbol);
                        if(helper) {
                            return {{transition, *helper}};
                        }
                    }
                }
                for(const TransitionType& transition: pureVariablePreStatePatternTransitions) {
                    std::optional<ApplyHelperType> helper = transition.matchFromCurrentCell(state, symbol);
                    if(helper) {
                        return {{transition, *helper}};
                    }
                }
                return {std::nullopt};
            }
            catch (std::out_of_range) {
                return {std::nullopt};
            }
        }
 
    private:
        StateType initialState;
        State::MConfiguration::MConfigurationMap<SymbolType, TransitionType> transitions;
        std::set<TransitionType> pureVariablePreStatePatternTransitions;
    };
}