simpleTuringMachineTransition.h

#pragma once
 
#include <symbol/simpleSymbolPattern.h>
#include <state/simpleStatePattern.h>
#include <transition/Turing/oneStepTuringMachineTransition.h>
 
namespace TuringSim::Transition::Turing {
 
    template <
            typename StateType_,
            typename SymbolType_,
            bool hasHalfTape = false>
    class SimpleTuringMachineTransition :
            public OneStepTuringMachineTransition<
                    StateType_,
                    SymbolType_,
                    std::monostate,
                    hasHalfTape
            > {
    private:
        typedef std::monostate ApplyHelperType_;
        typedef OneStepTuringMachineTransition<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<StateType_, StateType>);
        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<ApplyHelperType, std::monostate>);
        static_assert(std::is_same_v<typename Memory::TapeLike<hasHalfTape, SymbolType_>::Movement, Movement>);
 
        SimpleTuringMachineTransition() = delete;
 
        SimpleTuringMachineTransition(
                const StateType& preState,
                const SymbolType& preSymbol,
                const StateType& postState,
                const SymbolType& postSymbol,
                const Movement& movement) :
                LocalTuringMachineTransition_(),
                preState(preState),
                preSymbol(preSymbol),
                postState(postState),
                postSymbol(postSymbol),
                movement(movement){
        }
 
        SimpleTuringMachineTransition(const SimpleTuringMachineTransition&) = default;
 
        SimpleTuringMachineTransition(SimpleTuringMachineTransition&&) = default;
 
        SimpleTuringMachineTransition& operator=(const SimpleTuringMachineTransition&) = default;
 
        SimpleTuringMachineTransition& operator=(SimpleTuringMachineTransition&&) = default;
 
        virtual ~SimpleTuringMachineTransition() override = default;
 
        virtual std::optional<std::monostate> matchFromCurrentCell(const StateType& conf, const SymbolType& symbol) const override final {
            if(preSymbol.match(symbol) && preState.match(conf)) {
                return std::optional<std::monostate>(std::monostate());
            }
            return std::optional<std::monostate>();
        }
 
        virtual std::tuple<StateType, SymbolType, Movement> getPostElements(const StateType&, const SymbolType&, std::monostate&&) const override final {
            return this->getPostElementsTrivially();
        }
 
        std::tuple<StateType, SymbolType, Movement> getPostElementsTrivially() const {
            return {postState, postSymbol, movement};
        }
 
        const StateType& getPreState() const {
            return preState.getState();
        }
 
        const SymbolType& getPreSymbol() const {
            return preSymbol.getLetter();
        }
 
        bool operator<(const SimpleTuringMachineTransition& other) const {
            if(preState < other.preState) {
                return true;
            }
            if(other.preState < preState) {
                return false;
            }
            if(preSymbol < other.preSymbol) {
                return true;
            }
            if(other.preSymbol < preSymbol) {
                return false;
            }
            if(postState < other.postState) {
                return true;
            }
            if(other.postState < postState) {
                return false;
            }
            if(postSymbol < other.postSymbol) {
                return true;
            }
            if(other.postSymbol < postSymbol) {
                return false;
            }
            if(movement < other.movement) {
                return true;
            }
            if(other.movement < movement) {
                return false;
            }
            return false;
        }
 
    private:
        State::SimpleStatePattern<StateType> preState;
        Symbol::SimpleSymbolPattern<SymbolType> preSymbol;
        StateType postState;
        SymbolType postSymbol;
        Movement movement;
    };
}