deterministicSimpleTuringMachine.h

#pragma once
 
 
#include <variant>
#include <machine/Turing/simpleTuringMachine.h>
#include <transition/Turing/simpleTuringMachineTransition.h>
 
namespace TuringSim::Machine::Turing {
    template<
            typename StateType_,
            typename SymbolType_,
            bool hasHalfTape = false,
            AcceptingStyle acceptingStyle = AcceptingStyle::NonAccepting
    >
    class DeterministicSimpleTuringMachine :
            public SimpleTuringMachine<
                    StateType_,
                    SymbolType_,
                    true,
                    hasHalfTape,
                    acceptingStyle
            >
    {
        typedef SimpleTuringMachine<StateType_, SymbolType_, true, hasHalfTape, acceptingStyle> SimpleTuringMachine_;
    public:
        using typename SimpleTuringMachine_::StateType;
        using typename SimpleTuringMachine_::SymbolType;
        using typename SimpleTuringMachine_::HasHalfTape;
        using typename SimpleTuringMachine_::IsAccepting;
        using typename SimpleTuringMachine_::StorageType;
        using typename SimpleTuringMachine_::IsAlternating;
        using typename SimpleTuringMachine_::TransitionType;
        using typename SimpleTuringMachine_::ApplyHelperType;
        using typename SimpleTuringMachine_::IsDeterministic;
        using typename SimpleTuringMachine_::TransitionContainer;
        using typename SimpleTuringMachine_::InitialStateContainer;
        using typename SimpleTuringMachine_::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(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>>>);
 
        DeterministicSimpleTuringMachine() = delete;
        DeterministicSimpleTuringMachine(const DeterministicSimpleTuringMachine&) = default;
        DeterministicSimpleTuringMachine(DeterministicSimpleTuringMachine&&) = default;
        DeterministicSimpleTuringMachine& operator=(const DeterministicSimpleTuringMachine&) = default;
        DeterministicSimpleTuringMachine& operator=(DeterministicSimpleTuringMachine&&) = default;
        virtual ~DeterministicSimpleTuringMachine() override = default;
 
        DeterministicSimpleTuringMachine(
                const StateType& initialState,
                const std::set<StateType>& finalStates,
                const std::set<TransitionType>& transitions
        ) :
                SimpleTuringMachine_(finalStates),
                initialState(initialState),
                transitions() {
            for(const TransitionType& transition : transitions) {
                this->transitions[transition.getPreState()].insert({transition.getPreSymbol(), transition});
            }
        }
 
        virtual StateType getInitialState() const noexcept override final {
            return initialState;
        }
 
        virtual OptionalHelpedTransition getMatchingTransitionFromCurrentCell(const StateType& state, const SymbolType& symbol) const noexcept override final {
            try {
                return {{transitions.at(state).at(symbol), std::monostate()}};
            }
            catch (std::out_of_range) {
                return {std::nullopt};
            }
        }
 
    private:
        StateType initialState;
        std::map<StateType, std::map<SymbolType, TransitionType>> transitions;
    };
}