memoryStructure.h

#pragma once
 
#include <utils/messageException.h>
 
#include <set>
#include <sstream>
 
namespace TuringSim{
}
 
namespace TuringSim::Memory {
 
    class InvalidFactorException : public Utils::MessageException {
    public:
        InvalidFactorException() = delete;
 
        InvalidFactorException(std::string message, size_t sizeFactor) : MessageException(message), sizeFactor(sizeFactor) {}
 
        size_t getIllegalSizeFactor() const noexcept {
            return sizeFactor;
        }
    protected:
        virtual std::string makeFullMessage() const override {
            std::ostringstream ss;
            ss << this->msg << std::endl;
            ss << "  size factor: " << sizeFactor << std::endl;
            return ss.str();
        }
 
        size_t sizeFactor;  
    };
 
    template<typename Memory, typename Modifier>
    class ExistingModifierException : public Utils::MessageException {
    public:
        ExistingModifierException() = delete;
 
        ExistingModifierException(std::string message, const Memory* memory, const Modifier* modifier) :
                MessageException(message), memory(memory), modifier(modifier) {
        }
 
        const Memory* getMemory() const {
            return memory;
        }
 
        const Modifier* getModifier() const {
            return modifier;
        }
 
    protected:
        virtual std::string makeFullMessage() const override {
            std::ostringstream ss;
            ss << this->msg << std::endl;
            ss << "  memory structure address: " << memory << std::endl;
            ss << "  existing modifier address: " << modifier << std::endl;
            return ss.str();
        }
        const Memory* memory;  
        const Modifier* modifier; 
    };
 
    template <typename D, typename O>
    class MemoryObserver;
    template <typename D, typename M>
    class MemoryModifier;
 
    template <typename T, typename D, typename O, typename M>
    class MemoryStructure {
    public:
        typedef O Observer; 
        typedef M Modifier; 
        static_assert(std::is_base_of_v<MemoryObserver<D, O>, O>);
        static_assert(std::is_base_of_v<MemoryModifier<D, M>, M>);
        friend class MemoryObserver<D, O>;
        friend class MemoryModifier<D, M>;
        friend Observer;
        friend Modifier;
        typedef T SymbolType;
 
        ~MemoryStructure() {
            for(Observer* observer: observers) {
                observer->unsafe_release();
            }
            if(modifier) {
                (*modifier)->unsafe_release();
            }
        }
 
        const std::set<Observer*>& getObservers() const noexcept {
            return observers;
        }
 
        const std::optional<Modifier*>& getModifier() const noexcept {
            return modifier;
        }
 
    private:
        mutable std::set<Observer*> observers;
 
        mutable std::optional<Modifier*> modifier;
    };
 
    template <typename Memory, typename Observer>
    class MemoryObserver {
    public:
        MemoryObserver() noexcept : memory(nullptr) {}
 
        MemoryObserver(const Memory* memory) : MemoryObserver() {
            acquire(memory);
        }
 
        MemoryObserver(const MemoryObserver& other) {
            acquire(other->memory);
        }
 
        MemoryObserver(MemoryObserver&& other){
            acquire(other->memory);
            other.release();
        }
 
        MemoryObserver& operator=(MemoryObserver& other) {
            if(this != &other) {
                acquire(other->memory);
            }
            return *this;
        }
 
        MemoryObserver& operator=(MemoryObserver&& other) {
            if(this != &other) {
                acquire(other->memory);
                other.release();
            }
            return *this;
        }
 
        ~MemoryObserver() {
            release();
        }
 
        void acquire(const Memory* toAcquire) {
            if(memory == toAcquire){
                return;
            }
            release();
            if(toAcquire != nullptr) {
                memory = toAcquire;
                memory->observers.insert(static_cast<Observer*>(this));
            }
        }
 
        void unsafe_release() {
            memory->observers.erase(static_cast<Observer*>(this));
            memory = nullptr;
        }
 
        void release() {
            if(memory != nullptr) {
                unsafe_release();
            }
        }
 
        bool empty() const noexcept {
            return memory == nullptr;
        }
 
    protected:
        const Memory* memory;
    };
 
    template <typename Memory, typename Modifier>
    class MemoryModifier {
    public:
        MemoryModifier() : memory(nullptr) {}
        MemoryModifier(Memory* m) : MemoryModifier() {
            acquire(m);
        }
 
        MemoryModifier(const MemoryModifier& other) = delete;
 
        MemoryModifier(MemoryModifier&& other){
            Memory* otherMemory = other->memory;
            other.release();
            acquire(otherMemory);
        }
 
        MemoryModifier& operator=(MemoryModifier&) = delete;
 
        MemoryModifier& operator=(MemoryModifier&& other) {
            if(this != &other) {
                Memory* otherMemory = other->memory;
                other.release();
                acquire(otherMemory);
            }
            return *this;
        }
 
        ~MemoryModifier() {
            release();
        }
 
        void acquire(Memory* toAcquire) {
            if(memory == toAcquire) {
                return;
            }
            if(toAcquire->modifier) {
                throw ExistingModifierException("Memory structure already has a modifier", toAcquire, *toAcquire->modifier);
            }
            release();
            if(toAcquire != nullptr) {
                memory = toAcquire;
                memory->modifier = static_cast<Modifier*>(this);
            }
        }
 
        void force_acquire(Memory* toAcquire) {
            if(memory == toAcquire) {
                return;
            }
            release();
            if(toAcquire != nullptr) {
                if (toAcquire->modifier) {
                    (*toAcquire->modifier)->release();
                }
                memory = toAcquire;
                memory->modifier = static_cast<Modifier*>(this);
            }
        }
 
        void unsafe_release() {
            memory->modifier.reset();
            memory = nullptr;
        }
 
        void release() {
            if(memory != nullptr) {
                unsafe_release();
            }
        }
 
        bool empty() const noexcept {
            return memory == nullptr;
        }
 
    protected:
        Memory* memory;
    };
}