tm.hpp

Go to the documentation of this file.

 
#ifndef TURING_MACHINE_HPP
#define TURING_MACHINE_HPP
 
#include "alphabet.hpp"
#include "state.hpp"
#include "tape.hpp"
#include "transition.hpp"
 
#include <cstddef>
#include <set>
#include <string_view>
#include <unordered_map>
#include <vector>
 
class TuringMachine
{
  public:
    TuringMachine() noexcept : tape_count_(1) {}
 
    explicit TuringMachine(
        Alphabet input_alpha,
        Alphabet tape_alpha,
        std::set<State> states,
        State initial_state,
        std::size_t tape_count
    ) noexcept(false);
 
    [[nodiscard]] bool load_input(std::string_view input) noexcept(false);
 
    bool step() noexcept(false);
 
    void run() noexcept(false);
 
    [[nodiscard]] const Alphabet &get_input_alphabet() const noexcept
    {
        return this->input_alphabet_;
    }
 
    [[nodiscard]] const Alphabet &get_tape_alphabet() const noexcept
    {
        return this->tape_alphabet_;
    }
 
    [[nodiscard]] const std::set<State> &get_states() const noexcept { return this->states_; }
 
    [[nodiscard]] const State &get_start_state() const noexcept { return this->start_state_; }
 
    [[nodiscard]] const State &get_current_state() const noexcept { return this->current_state_; }
 
    [[nodiscard]] const std::vector<Tape> &get_tapes() const noexcept { return this->tapes_; }
 
    [[nodiscard]] const std::unordered_map<std::size_t, Transition> &
    get_transitions() const noexcept
    {
        return this->transitions_;
    }
 
    [[nodiscard]] std::size_t get_tape_count() const noexcept { return this->tape_count_; }
 
    std::size_t add_transition(
        State current,
        State next,
        std::vector<Symbol> read,
        std::vector<Symbol> write,
        std::vector<Direction> dir
    ) noexcept(false)
    {
        auto [it, success] = this->transitions_.emplace(
            this->id_counter_,
            Transition(
                this->id_counter_,
                std::move(current),
                std::move(next),
                std::move(read),
                std::move(write),
                std::move(dir)
            )
        );
        if (success)
        {
            return this->id_counter_++;
        }
        return it->first; // Return existing ID if transition already exists
    }
 
    [[nodiscard]] Transition *get_transition(std::size_t id) noexcept
    {
        auto it = this->transitions_.find(id);
        if (it != this->transitions_.end())
        {
            return &(it->second);
        }
        return nullptr;
    }
 
    bool remove_transition(std::size_t id) noexcept { return this->transitions_.erase(id) > 0; }
 
    [[nodiscard]] bool contains_transition(std::size_t id) const noexcept
    {
        return this->transitions_.contains(id);
    }
 
  private:
    std::size_t id_counter_{0}; 
    Alphabet input_alphabet_;   
    Alphabet tape_alphabet_;    
    std::set<State> states_;    
    State start_state_;         
    State current_state_;       
    std::vector<Tape> tapes_;   
    std::unordered_map<std::size_t, Transition>
        transitions_;        
    std::size_t tape_count_; 
};
 
#endif // TURING_MACHINE_HPP