oneStepTuringMachineTransition.h

#pragma once
 
#include <symbol/symbolPattern.h>
#include <transition/Turing/localTuringMachineTransition.h>
 
namespace TuringSim::Transition::Turing {
    template<
            typename StateType_,
            typename SymbolType_,
            typename ApplyHelperType_,
            bool hasHalfTape = false
    >
    class OneStepTuringMachineTransition : public LocalTuringMachineTransition<StateType_, SymbolType_, ApplyHelperType_, hasHalfTape> {
        typedef LocalTuringMachineTransition<StateType_, SymbolType_, ApplyHelperType_, hasHalfTape> LocalTuringMachineTransition_;
    public:
        using typename LocalTuringMachineTransition_::Movement;
        using typename LocalTuringMachineTransition_::StateType;
        using typename LocalTuringMachineTransition_::SymbolType;
        using typename LocalTuringMachineTransition_::HasHalfTape;
        using typename LocalTuringMachineTransition_::StorageType;
        using typename LocalTuringMachineTransition_::ApplyHelperType;
 
        static_assert(std::is_same_v<SymbolType_, SymbolType>);
        static_assert(std::is_same_v<Memory::TapeLike<hasHalfTape, SymbolType_>, StorageType>);
        static_assert(std::is_same_v<StateType_, StateType>);
        static_assert(std::is_same_v<StateType, StateType_>);
 
        OneStepTuringMachineTransition() = default;
 
        OneStepTuringMachineTransition(const OneStepTuringMachineTransition&) = default;
 
        OneStepTuringMachineTransition(OneStepTuringMachineTransition&&) = default;
 
        OneStepTuringMachineTransition& operator=(const OneStepTuringMachineTransition&) = default;
 
        OneStepTuringMachineTransition& operator=(OneStepTuringMachineTransition&&) = default;
 
        virtual ~OneStepTuringMachineTransition() override = default;
 
        virtual StateType apply(const StateType& state, Memory::TapeLike<hasHalfTape, SymbolType_>& tape, ApplyHelperType&& helper, bool& running) const override final {
            auto&& [postState, postSymbol, movement] = this->getPostElements(state, tape.read(), std::move(helper));
            tape.write(postSymbol);
            tape.move(movement);
            if(movement == Movement::HALT) {
                running = false;
            }
            return postState;
        }
 
        virtual std::tuple<StateType, SymbolType, Movement> getPostElements(const StateType& state, const SymbolType& symbol, ApplyHelperType&& helper) const = 0;
    };
}