word.h

#pragma once
 
#include <memory/memoryStructure.h>
 
#include <vector>
 
namespace TuringSim::Memory::Word {
    template <typename T> class WordObserver;
    template <typename T> class WordModifier;
 
    template<typename T>
    class Word : public MemoryStructure<T, Word<T>, WordObserver<T>, WordModifier<T>> {
        friend class WordObserver<T>;
 
        friend class WordModifier<T>;
    public:
 
        constexpr Word();
 
        constexpr Word(const std::vector<T>& word);
 
        constexpr Word(const Word<T>& other);
 
        constexpr Word(Word<T>&& other);
 
        constexpr Word<T>& operator=(const Word<T>& other);
 
        constexpr Word<T>& operator=(Word<T>&& other);
 
        ~Word() = default;
 
        const T& read();
 
        std::optional<T> read_opt() noexcept;
 
        [[nodiscard]] const T& front() const;
 
        [[nodiscard]] std::optional<T> front_opt() const noexcept;
 
        [[nodiscard]] bool isEndOfWord() const noexcept;
 
    private:
        std::vector<T> word;
        size_t position;
    };
 
    class WordOverflowException : public Utils::MessageException {
    public:
        WordOverflowException() = delete;
 
        WordOverflowException(std::string message, size_t length, size_t position) :
                Utils::MessageException(message),
                length(length),
                position(position)
        {}
 
    protected:
        virtual std::string makeFullMessage() const override {
            std::ostringstream ss;
            ss << this->msg << std::endl;
            ss << "  length: " << length << std::endl;
            ss << "  position: " << position << std::endl;
            return ss.str();
        }
 
        size_t length;
 
        size_t position;
    };
 
    template<typename T>
    constexpr Word<T>::Word() :
            word(), position(0)
    {}
 
    template<typename T>
    constexpr Word<T>::Word(const std::vector<T>& word) :
            word(word), position(0)
    {}
 
    template<typename T>
    constexpr Word<T>::Word(const Word<T> &other) :
            word(other.word), position(other.position)
    {}
 
    template<typename T>
    constexpr Word<T>::Word(Word<T> &&other) :
            word(std::move(other.word)), position(std::move(other.position))
    {}
 
    template<typename T>
    constexpr Word<T> &Word<T>::operator=(const Word<T>& other) {
        if(this != &other) {
            word = other.word;
            position = other.position;
        }
        return *this;
    }
 
    template<typename T>
    constexpr Word<T> &Word<T>::operator=(Word<T>&& other) {
        if(this != &other) {
            word = std::move(other.word);
            position = std::move(other.position);
        }
        return *this;
    }
 
    template<typename T>
    const T& Word<T>::read() {
        if(position < word.size()) {
            return word[position++];
        }
        throw WordOverflowException("End of word reached in Word<T>::read()", word.size(), position);
    }
 
    template<typename T>
    std::optional<T> Word<T>::read_opt() noexcept {
        if(position < word.size()) {
            return word[position++];
        }
        return std::nullopt;
    }
 
    template<typename T>
    const T& Word<T>::front() const {
        if(position < word.size()) {
            return word[position];
        }
        throw WordOverflowException("End of word reached in Word<T>::front()", word.size(), position);
    }
 
    template<typename T>
    std::optional<T> Word<T>::front_opt() const noexcept {
        if(position < word.size()) {
            return std::make_optional(word[position]);
        }
        return std::nullopt;
    }
 
    template<typename T>
    bool Word<T>::isEndOfWord() const noexcept {
        return position == word.size();
    }
 
    template <typename T>
    class WordObserver : public MemoryObserver<Word<T>, WordObserver<T>> {
    public:
        constexpr WordObserver(Word<T>& word) : MemoryObserver<Word<T>, WordObserver<T>>(&word) {}
 
        [[nodiscard]] size_t getPosition() const noexcept {
            return this->memory->position;
        }
 
        [[nodiscard]] const std::vector<T>& getWord() const noexcept {
            return this->memory->word;
        }
 
        [[nodiscard]] size_t getSize() const noexcept {
            return this->memory->word.size();
        }
    };
 
    template <typename T>
    class WordModifier : public MemoryModifier<Word<T>, WordModifier<T>> {
    public:
        constexpr WordModifier(Word<T>& word) : MemoryModifier<Word<T>, WordModifier<T>>(&word) {}
 
        constexpr void setPosition(size_t position) {
            if(position > this->memory->word.size()) {
                throw WordOverflowException("Illegal position in WordModifier<T>::setPosition", this->memory->word.size(), position);
            }
            this->memory->position = position;
        }
 
        constexpr T& operator[](size_t position) {
            if(position >= this->memory->word.size()) {
                throw WordOverflowException("Illegal position in WordModifier<T>::operator[]", this->memory->word.size(), position);
            }
            return this->memory->word[position];
        }
 
        constexpr void setWord(const std::vector<T>& word) {
            if(this->memory->position > word.size()) {
                throw WordOverflowException("Illegal position in WordModifier<T>::setWord", this->memory->word.size(), this->memory->position);
            }
            this->memory->word = word;
        }
    };
}