mConfigurationTuringMachineTransition.h

#pragma once
 
#include <utils/visitor.h>
#include <state/mConfiguration/mConfiguration.h>
#include <transition/Turing/localTuringMachineTransition.h>
 
namespace TuringSim::Transition::Turing {
 
    template <typename T>
    using MConfigurationTuringMachineTransitionApplyHelper = std::map<T, std::shared_ptr<const State::MConfiguration::MConfiguration<T>>>;
 
    template<
            typename NodeStateType_,
            typename SymbolType_,
            bool hasHalfTape
            >
    class MConfigurationTuringMachineTransition
            : public LocalTuringMachineTransition<
                    std::shared_ptr<const State::MConfiguration::MConfiguration<NodeStateType_>>,
                    SymbolType_,
                    MConfigurationTuringMachineTransitionApplyHelper<NodeStateType_>,
                    hasHalfTape
            > {
        typedef std::shared_ptr<const State::MConfiguration::MConfiguration<NodeStateType_>> StateType_;
        typedef MConfigurationTuringMachineTransitionApplyHelper<NodeStateType_> ApplyHelperType_;
        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;
 
        typedef NodeStateType_ NodeStateType;
 
        typedef ApplyHelperType SubstitutionType;
 
        struct MovementInstruction {
            Movement movement; 
            bool operator==(const MovementInstruction& other) const { return movement == other.movement; }
 
            bool operator!=(const MovementInstruction& other) const { return movement != other.movement; }
 
            bool operator<(const MovementInstruction& other) const { return movement < other.movement; }
        };
 
        struct EraseInstruction {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
            bool operator==(const EraseInstruction& other) const { return true; }
 
            bool operator!=(const EraseInstruction& other) const { return false; }
 
            bool operator<(const EraseInstruction& other) const { return false; }
#pragma clang diagnostic pop
        };
 
        struct WriteInstruction {
            SymbolType symbol;  
            bool operator==(const WriteInstruction& other) const { return symbol == other.symbol; }
 
            bool operator!=(const WriteInstruction& other) const { return symbol != other.symbol; }
 
            bool operator<(const WriteInstruction& other) const { return symbol < other.symbol; }
        };
 
        typedef std::variant<MovementInstruction, EraseInstruction, WriteInstruction> Instruction;
 
        template <typename CharT = char, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const MovementInstruction&  mi) {
            os << "move(" << mi.movement << ")";
            return
            os;
        }
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        template <typename CharT = char, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const EraseInstruction& ei) {
            os << "erase";
            return os;
        }
#pragma clang diagnostic pop
 
        template <typename CharT = char, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const WriteInstruction& wi) {
            os << "write(" << wi.symbol << ")";
            return os;
        }
 
        template <typename CharT = char, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const Instruction& i) {
            using Utils::Visitor;
            std::visit(
                    Visitor{
                            [&os](const MovementInstruction& mi) {
                                os << mi;
                            },
                            [&os](const EraseInstruction& ei) {
                                os << ei;
                            },
                            [&os](const WriteInstruction& wi) {
                                os << wi;
                            },
                    },
                    i);
            return os;
        }
 
        MConfigurationTuringMachineTransition() = default;
 
        MConfigurationTuringMachineTransition(const MConfigurationTuringMachineTransition&) = default;
 
        MConfigurationTuringMachineTransition(MConfigurationTuringMachineTransition&&) = default;
 
        MConfigurationTuringMachineTransition& operator=(const MConfigurationTuringMachineTransition&) = default;
 
        MConfigurationTuringMachineTransition& operator=(MConfigurationTuringMachineTransition&&) = default;
 
        virtual ~MConfigurationTuringMachineTransition() override = default;
 
    protected:
        void run_instruction(StorageType& tape, const Instruction& instruction) const {
            using Utils::Visitor;
            std::visit(
                    Visitor{
                            [&tape](const MovementInstruction& m) -> void { tape.move(m.movement); },
                            [&tape](const EraseInstruction& ) -> void { tape.erase(); },
                            [&tape](const WriteInstruction& w) -> void { tape.write(w.symbol); },
                    },
                    instruction);
        }
 
        void run_instructions(StorageType& tape, bool& running, const std::vector<Instruction>& instructions) const {
            for (const Instruction& i: instructions) {
                try {
                    const MovementInstruction& mi = std::get<MovementInstruction>(i);
                    if (mi.movement == StorageType::Movement::HALT) {
                        running = false;
                        break;
                    }
                }
                catch (std::bad_variant_access) {  // If [i] is not a movement instruction.
                }
                run_instruction(tape, i);
            }
        }
    };
}