tape.h

#pragma once
 
#include <utils/messageException.h>
#include <memory/memoryStructure.h>
 
#include <vector>
 
namespace TuringSim::Memory::Tape {
    template <typename T> class TapeObserver;
    template <typename T> class TapeModifier;
 
    template<typename T>
    class Tape : public MemoryStructure<T, Tape<T>, TapeObserver<T>, TapeModifier<T>> {
        friend class TapeObserver<T>;
 
        friend class TapeModifier<T>;
 
    public:
        static constexpr size_t MinAllocatedTapeSize = 10;
 
        enum class Movement {
            LEFT,  
            RIGHT, 
            NONE,  
            HALT,  
        };
 
        constexpr Tape();
 
        constexpr Tape(const T& blank);
 
        constexpr Tape(const Tape<T>& other);
 
        constexpr Tape(Tape<T>&& other);
 
        constexpr Tape<T>& operator=(const Tape<T>& other);
 
        constexpr Tape<T>& operator=(Tape<T>&& other);
 
        ~Tape() = default;
 
        constexpr void left();
 
        constexpr void right();
 
        constexpr void move(const Movement& movement);
 
        [[nodiscard]] constexpr const T& read() const;
 
        constexpr void write(const T& symbol);
 
        constexpr void erase();
 
        template<typename CharT = char, typename Trait = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Trait>& operator<<(std::basic_ostream<CharT, Trait>& os, const Movement& movement) {
            switch (movement) {
                case Tape<T>::Movement::LEFT:
                    os << "LEFT"; break;
                case Tape<T>::Movement::RIGHT:
                    os << "RIGHT"; break;
                case Tape<T>::Movement::NONE:
                    os << "NONE"; break;
                case Tape<T>::Movement::HALT:
                    os << "HALT"; break;
            }
            return os;
        }
 
    private:
        constexpr void allocateLeft();
        constexpr void allocateRight();
        constexpr void allocate();
        constexpr void allocateLeft(size_t);
        constexpr void allocateRight(size_t);
        constexpr void allocate(size_t);
        void setSizeFactor(size_t);
        constexpr void shrink();
        constexpr void shrink(std::vector<T>&, size_t);
 
        T blank;
        std::vector<T> leftTape = std::vector<T>(MinAllocatedTapeSize, blank);
        std::vector<T> rightTape = std::vector<T>(MinAllocatedTapeSize, blank);
        std::vector<T>* currentTape;
        size_t position = 0;
        bool onRight = true;
 
        size_t sizeFactor = 2;
    };
 
 
    template <typename T>
    constexpr Tape<T>::Tape() :
            blank(T()),
            currentTape(&rightTape)
    {}
 
    template <typename T>
    constexpr Tape<T>::Tape(const T& blank) :
            blank(blank),
            currentTape(&rightTape)
    {}
 
    template <typename T>
    constexpr Tape<T>::Tape(const Tape<T>& other) :
            blank(other.blank),
            leftTape(other.leftTape),
            rightTape(other.rightTape),
            currentTape(other.currentTape),
            position(other.position),
            onRight(other.onRight),
            sizeFactor(other.sizeFactor)
    {}
 
    template <typename T>
    constexpr Tape<T>::Tape(Tape<T>&& other) :
            blank(std::move(other.blank)),
            leftTape(std::move(other.leftTape)),
            rightTape(std::move(other.rightTape)),
            currentTape(other.onRight ? &leftTape : &rightTape),
            position(std::move(other.position)),
            onRight(std::move(other.onRight)),
            sizeFactor(std::move(other.sizeFactor))
    {}
 
    template <typename T>
    constexpr Tape<T>& Tape<T>::operator=(const Tape<T>& other)
    {
        if(this != &other) {
            blank = other.blank;
            leftTape = other.leftTape;
            rightTape = other.rightTape;
            currentTape = other.currentTape;
            position = other.position;
            onRight = other.onRight;
            sizeFactor = other.sizeFactor;
        }
        return *this;
    }
 
    template <typename T>
    constexpr Tape<T>& Tape<T>::operator=(Tape<T>&& other)
    {
        if(this != &other) {
            blank = std::move(other.blank);
            leftTape = std::move(other.leftTape);
            rightTape = std::move(other.rightTape);
            currentTape = other.onRight ? &leftTape : &rightTape;
            position = std::move(other.position);
            onRight = std::move(other.onRight);
            sizeFactor = std::move(other.sizeFactor);
        }
        return *this;
    }
 
 
    template <typename T>
    constexpr void Tape<T>::left()
    {
        if(onRight) {
            if(position) {
                position--;
            }
            else {
                onRight = false;
                currentTape = &leftTape;
            }
        }
        else {
            position++;
            if(position >= leftTape.size()) {
                allocateLeft();
            }
        }
    }
 
    template <typename T>
    constexpr void Tape<T>::allocateLeft()
    {
        leftTape.resize(leftTape.size()*sizeFactor, blank);
    }
 
    template <typename T>
    constexpr void Tape<T>::allocateLeft(size_t e)
    {
        leftTape.resize(leftTape.size() + e, blank);
    }
 
    template <typename T>
    constexpr void Tape<T>::right()
    {
        if(onRight) {
            position++;
            if(position >= rightTape.size()) {
                allocateRight();
            }
        }
        else {
            if(position) {
                position--;
            }
            else {
                onRight = true;
                currentTape = &rightTape;
            }
        }
    }
 
    template <typename T>
    constexpr void Tape<T>::allocateRight()
    {
        rightTape.resize(rightTape.size()*sizeFactor, blank);
    }
 
    template <typename T>
    constexpr void Tape<T>::allocateRight(size_t e)
    {
        rightTape.resize(rightTape.size() + e, blank);
    }
 
    template <typename T>
    constexpr void Tape<T>::move(const Movement& m)
    {
        switch(m)
        {
            case Movement::LEFT:
                left();
                break;
            case Movement::RIGHT:
                right();
                break;
            case Movement::HALT:
            case Movement::NONE:
                break;
        }
    }
 
    template <typename T>
    constexpr void Tape<T>::allocate()
    {
        allocateRight();
        allocateLeft();
    }
 
    template <typename T>
    constexpr void Tape<T>::allocate(size_t e)
    {
        allocateRight(e);
        allocateLeft(e);
    }
 
    template <typename T>
    constexpr const T& Tape<T>::read() const
    {
        return (*currentTape)[position];
    }
 
    template <typename T>
    constexpr void Tape<T>::write(const T& e)
    {
        (*currentTape)[position] = e;
    }
 
    template <typename T>
    constexpr void Tape<T>::erase()
    {
        (*currentTape)[position] = blank;
    }
 
    template <typename T>
    void Tape<T>::setSizeFactor(size_t e)
    {
        if(e < 2) {
            throw InvalidFactorException("Size factor is too small in Tape<T>::setSizeFactor(size_t). Must be > 1.", e);
        }
        sizeFactor = e;
    }
 
    template <typename T>
    constexpr void Tape<T>::shrink()
    {
        shrink(leftTape, onRight ? 0 : position);
        shrink(rightTape, onRight ? position : 0);
    }
 
    template <typename T>
    constexpr void Tape<T>::shrink(std::vector<T>& tape, size_t inf)
    {
        size_t idxOfLastNonBlank = tape.size()-1;
 
        for(; idxOfLastNonBlank > MinAllocatedTapeSize-1 && tape[idxOfLastNonBlank] == blank; --idxOfLastNonBlank){
        }
 
        tape.resize(std::max(idxOfLastNonBlank, inf) + 1);
    }
 
    template <typename T>
    class TapeObserver : public MemoryObserver<Tape<T>, TapeObserver<T>>
    {
    public:
        constexpr TapeObserver(const Tape<T>& tape) : MemoryObserver<Tape<T>, TapeObserver<T>>(&tape) {}
 
        [[nodiscard]] constexpr size_t getRightSize() const { return this->memory->rightTape.size(); }
 
        [[nodiscard]] constexpr size_t getLeftSize() const { return this->memory->leftTape.size(); }
 
        [[nodiscard]] constexpr const std::vector<T>& getRightTape() const { return this->memory->rightTape; }
 
        [[nodiscard]] constexpr const std::vector<T>& getLeftTape() const { return this->memory->leftTape; }
 
        [[nodiscard]] constexpr const std::vector<T>* getCurrentTape() const { return this->memory->currentTape; }
 
        [[nodiscard]] constexpr size_t getSizeFactor() const { return this->memory->sizeFactor; }
 
        [[nodiscard]] constexpr const T& getBlank() const { return this->memory->blank; }
 
        [[nodiscard]] constexpr bool isOnRight() const { return this->memory->onRight; }
 
        [[nodiscard]] constexpr size_t getAbsolutePosition() const { return this->memory->position; }
 
        [[nodiscard]] constexpr long long int getPosition() const { return this->memory->onRight ?
                                                             static_cast<long long int>(this->memory->position) :
                                                             -static_cast<long long int>(this->memory->position)-1; }
 
        [[nodiscard]] constexpr const T& operator[](long long int position) const {
            if (position >= 0) {
                typename std::vector<T>::size_type i = static_cast<typename std::vector<T>::size_type>(position);
                if (i < this->memory->rightTape.size()) {
                    return this->memory->rightTape[i];
                }
                return this->memory->blank;
            } else {
                typename std::vector<T>::size_type i = static_cast<typename std::vector<T>::size_type>(-position - 1);
                if (i < this->memory->leftTape.size()) {
                    return this->memory->leftTape[i];
                }
                return this->memory->blank;
            }
        }
    };
 
    template <typename T>
    class TapeModifier : public MemoryModifier<Tape<T>, TapeModifier<T>>
    {
    public:
        constexpr TapeModifier(Tape<T>& tape) : MemoryModifier<Tape<T>, TapeModifier<T>>(&tape) {}
        constexpr void allocateRight() const { this->memory->allocateRight(); }
        constexpr void allocateLeft() const { this->memory->allocateLeft(); }
        constexpr void allocate() const { this->memory->allocate(); }
        constexpr void allocateRight(size_t additionalSize) const { this->memory->allocateRight(additionalSize); }
        constexpr void allocateLeft(size_t additionalSize) const { this->memory->allocateLeft(additionalSize); }
        constexpr void allocate(size_t additionalSize) const { this->memory->allocate(additionalSize); }
        constexpr void shrink() const { this->memory->shrink(); }
        constexpr void setSizeFactor(size_t newSizeFactor) const { this->memory->setSizeFactor(newSizeFactor); }
 
        constexpr void setPosition(long long int position) {
            if(position >= 0) {
                size_t position_u = static_cast<size_t>(position);
                this->memory->position = position_u;
                this->memory->onRight = true;
                size_t rSize = this->memory->rightTape.size();
                if(position_u >= rSize) {
                    this->memory->allocateRight(position_u - rSize + 1);
                }
                this->memory->currentTape = &this->memory->rightTape;
            }
            else {
                size_t position_u = static_cast<size_t>(- position - 1);
                this->memory->position = position_u;
                this->memory->onRight = false;
                size_t lSize = this->memory->leftTape.size();
                if(position_u >= lSize) {
                    this->memory->allocateLeft(position_u - lSize + 1);
                }
                this->memory->currentTape = &this->memory->leftTape;
            }
        }
 
        constexpr T& operator[](long long int position) {
            if(position >= 0) {
                typename std::vector<T>::size_type i = static_cast<typename std::vector<T>::size_type>(position);
                size_t rSize = this->memory->rightTape.size();
                if(i >= rSize) {
                    this->memory->allocateRight(i - rSize + 1);
                }
                return this->memory->rightTape[i];
            }
            else {
                typename std::vector<T>::size_type i = static_cast<typename std::vector<T>::size_type>(- position - 1);
                size_t lSize = this->memory->leftTape.size();
                if(i >= lSize) {
                    this->memory->allocateRight(i - lSize + 1);
                }
                return this->memory->leftTape[i];
            }
        }
    };
}