localTuringMachineTransition.h

#pragma once
 
#include <symbol/symbolPattern.h>
#include <transition/Turing/turingMachineTransition.h>
 
namespace TuringSim::Transition::Turing {
 
    template<
            typename StateType_,
            typename SymbolType_,
            typename ApplyHelperType_,
            bool hasHalfTape = false
    >
    class LocalTuringMachineTransition : public TuringMachineTransition<StateType_, SymbolType_, ApplyHelperType_, hasHalfTape> {
        typedef TuringMachineTransition<StateType_, SymbolType_, ApplyHelperType_, hasHalfTape> TuringMachineTransition_;
    public:
        using typename TuringMachineTransition_::Movement;
        using typename TuringMachineTransition_::StateType;
        using typename TuringMachineTransition_::SymbolType;
        using typename TuringMachineTransition_::HasHalfTape;
        using typename TuringMachineTransition_::StorageType;
        using typename TuringMachineTransition_::ApplyHelperType;
 
        static_assert(std::is_same_v<SymbolType, SymbolType_>);
        static_assert(std::is_same_v<StorageType, Memory::TapeLike<hasHalfTape, SymbolType_>>);
        static_assert(std::is_same_v<StateType, StateType_>);
 
        LocalTuringMachineTransition() = default;
 
        LocalTuringMachineTransition(const LocalTuringMachineTransition&) = default;
 
        LocalTuringMachineTransition(LocalTuringMachineTransition&&) = default;
 
        LocalTuringMachineTransition& operator=(const LocalTuringMachineTransition&) = default;
 
        LocalTuringMachineTransition& operator=(LocalTuringMachineTransition&&) = default;
 
        virtual ~LocalTuringMachineTransition() override = default;
 
        virtual std::optional<ApplyHelperType> match(const StateType& state, const StorageType& tape) const override final {
            return this->matchFromCurrentCell(state, tape.read());
        }
 
        virtual std::optional<ApplyHelperType> matchFromCurrentCell(const StateType& state, const SymbolType& symbol) const = 0;
    };
}