weakptr.hpp

Go to the documentation of this file.

#pragma once
#include <common.hpp>
 
 
namespace rack {
 
 
struct WeakHandle {
    void* ptr;
    size_t count = 0;
    WeakHandle(void* ptr) : ptr(ptr) {}
};
 
 
struct WeakBase {
    WeakHandle* weakHandle = nullptr;
 
    ~WeakBase() {
        if (weakHandle) {
            weakHandle->ptr = nullptr;
        }
    }
    size_t getWeakCount() {
        if (!weakHandle)
            return 0;
        return weakHandle->count;
    }
};
 
 
template <typename T>
struct WeakPtr {
    WeakHandle* weakHandle = NULL;
 
    WeakPtr() {}
    WeakPtr(T* ptr) {
        set(ptr);
    }
    WeakPtr(const WeakPtr& other) {
        set(other.get());
    }
    WeakPtr& operator=(const WeakPtr& other) {
        set(other.get());
        return *this;
    }
    ~WeakPtr() {
        set(nullptr);
    }
    void set(T* ptr) {
        // Release handle
        if (weakHandle) {
            // Decrement and check handle reference count
            if (--weakHandle->count == 0) {
                // Remove handle from object and delete it
                T* oldPtr = reinterpret_cast<T*>(weakHandle->ptr);
                if (oldPtr) {
                    oldPtr->weakHandle = nullptr;
                }
                delete weakHandle;
            }
            weakHandle = nullptr;
        }
        // Obtain handle
        if (ptr) {
            if (!ptr->weakHandle) {
                // Create new handle for object
                ptr->weakHandle = new WeakHandle(ptr);
            }
            weakHandle = ptr->weakHandle;
            // Increment handle reference count
            weakHandle->count++;
        }
    }
    T* get() const {
        if (!weakHandle)
            return nullptr;
        return reinterpret_cast<T*>(weakHandle->ptr);
    }
    T* operator->() const {
        return get();
    }
    T& operator*() const {
        return *get();
    }
    operator T*() const {
        return get();
    }
    explicit operator bool() const {
        return get();
    }
};
 
 
} // namespace rack