transition.hpp

Go to the documentation of this file.

 
#ifndef TRANSITION_HPP
#define TRANSITION_HPP
 
#include "direction.hpp"
#include "state.hpp"
#include "symbol.hpp"
 
#include <utility>
#include <vector>
 
class Transition
{
  public:
    Transition() = default;
 
    explicit Transition(
        std::size_t id,
        State current,
        State next,
        std::vector<Symbol> read,
        std::vector<Symbol> write,
        std::vector<Direction> dir
    ) noexcept
        : id_(id), current_state_(std::move(current)), next_state_(std::move(next)),
          read_symbols_(std::move(read)), write_symbols_(std::move(write)),
          dir_vectors_(std::move(dir))
    {}
 
    [[nodiscard]] std::size_t get_id() const noexcept { return this->id_; }
 
    [[nodiscard]] const State &get_current_state() const noexcept { return this->current_state_; }
 
    [[nodiscard]] const State &get_next_state() const noexcept { return this->next_state_; }
 
    [[nodiscard]] const std::vector<Symbol> &get_read_symbols() const noexcept
    {
        return this->read_symbols_;
    }
 
    [[nodiscard]] const std::vector<Symbol> &get_write_symbols() const noexcept
    {
        return this->write_symbols_;
    }
 
    [[nodiscard]] const std::vector<Direction> &get_directions() const noexcept
    {
        return this->dir_vectors_;
    }
 
    [[nodiscard]] bool operator==(const Transition &other) const noexcept
    {
        return this->current_state_ == other.current_state_ &&
               this->read_symbols_ == other.read_symbols_;
    }
 
    [[nodiscard]] auto operator<=>(const Transition &other) const noexcept
    {
        if (auto cmp = this->current_state_ <=> other.current_state_; cmp != nullptr)
        {
            return cmp;
        }
        return this->read_symbols_ <=> other.read_symbols_;
    }
 
    void set_next_state(State next) noexcept { this->next_state_ = std::move(next); }
 
    void set_read_symbols(std::vector<Symbol> read) noexcept
    {
        this->read_symbols_ = std::move(read);
    }
 
    void set_write_symbols(std::vector<Symbol> write) noexcept
    {
        this->write_symbols_ = std::move(write);
    }
 
    void set_directions(std::vector<Direction> dir) noexcept
    {
        this->dir_vectors_ = std::move(dir);
    }
 
    void set_read_symbol_at(std::size_t tape_idx, const Symbol &sym) noexcept(false)
    {
        if (tape_idx >= this->read_symbols_.size())
        {
            throw std::out_of_range("Tape index out of bounds for read_symbols_");
        }
        this->read_symbols_[tape_idx] = sym;
    }
 
    void set_write_symbol_at(std::size_t tape_idx, const Symbol &sym) noexcept(false)
    {
        if (tape_idx >= this->write_symbols_.size())
        {
            throw std::out_of_range("Tape index out of bounds for write_symbols_");
        }
        this->write_symbols_[tape_idx] = sym;
    }
 
    void set_direction_at(std::size_t tape_idx, const Direction &dir) noexcept(false)
    {
        if (tape_idx >= this->dir_vectors_.size())
        {
            throw std::out_of_range("Tape index out of bounds for dir_vectors_");
        }
        this->dir_vectors_[tape_idx] = dir;
    }
 
  private:
    std::size_t id_{0};   
    State current_state_; 
    State next_state_;    
    std::vector<Symbol> read_symbols_;   
    std::vector<Symbol> write_symbols_;  
    std::vector<Direction> dir_vectors_; 
};
 
#endif // TRANSITION_HPP