sharedptr.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cassert>
#include <typeinfo>
#include <utility>
#include <promeki/core/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
#define PROMEKI_SHARED(BASE) \
    public: \
        RefCount _promeki_refct; \
        virtual BASE *_promeki_clone() const { return new BASE(*this); }
 
#define PROMEKI_SHARED_DERIVED(BASE, DERIVED) \
    public: \
        virtual BASE *_promeki_clone() const override { return new DERIVED(*this); }
 
#define PROMEKI_SHARED_FINAL(TYPE) \
    public: \
        RefCount _promeki_refct; \
        TYPE *_promeki_clone() const { return new TYPE(*this); }
 
class RefCount {
    public:
        static constexpr int Immortal = 0x40000000;
 
        RefCount() : v(1) {}
 
        RefCount(const RefCount &o) : v(1) {}
 
        RefCount &operator=(const RefCount &) { v.store(1, std::memory_order_relaxed); return *this; }
 
        void inc() {
            if(v.load(std::memory_order_relaxed) >= Immortal) return;
            v.fetch_add(1, std::memory_order_relaxed);
            return;
        }
 
        bool dec() {
            if(v.load(std::memory_order_relaxed) >= Immortal) return false;
            return v.fetch_sub(1, std::memory_order_acq_rel) == 1;
        }
 
        int value() const {
            return v.load(std::memory_order_relaxed);
        }
 
        bool isImmortal() const {
            return v.load(std::memory_order_relaxed) >= Immortal;
        }
 
        void setImmortal() {
            v.store(Immortal, std::memory_order_relaxed);
        }
 
    private:
        std::atomic<int>    v;
};
 
template<typename T>
class SharedPtrProxy {
    public:
        RefCount    _promeki_refct;
 
        SharedPtrProxy(T *o) : _object(o) {}
        ~SharedPtrProxy() { delete _object; }
        T *_promeki_clone() const {
            // When using a proxy data type, i.e. not a "native" shared object,
            // there's no way to make a copy from a derived object work.
            assert(typeid(*_object) == typeid(T));
            return new T(*_object);
        }
        T *object() const { return _object; }
    private:
        T *_object = nullptr;
};
 
template<typename T, typename = void> struct IsSharedObject : std::false_type {};
template<typename T> struct IsSharedObject<T, std::void_t<decltype(&T::_promeki_refct)>> : std::true_type {};
 
template<typename T, bool CopyOnWrite = true, typename ST = std::conditional_t<IsSharedObject<T>::value, T, SharedPtrProxy<T>>>
class SharedPtr {
    public:
        static constexpr bool isNative = IsSharedObject<T>::value;
 
        // Any attempt to modify the object when it's shared (i.e. a reference
        // count > 1), the object will be copied first and that new object
        // will be the one that's modified.
        static constexpr bool isCopyOnWrite = CopyOnWrite;
 
        SharedPtr() = default;
 
        SharedPtr(const SharedPtr &sp) : _data(sp._data) { acquire(); }
        SharedPtr(SharedPtr &&sp) noexcept : _data(sp._data) { sp._data = nullptr; }
        ~SharedPtr() { release(); }
 
        template<typename... Args>
        static SharedPtr create(Args&&... args) {
            SharedPtr sp;
            sp.setData(new T(std::forward<Args>(args)...));
            return sp;
        }
 
        static SharedPtr takeOwnership(T *obj) {
            SharedPtr sp;
            if(obj != nullptr) sp.setData(obj);
            return sp;
        }
 
        SharedPtr &operator=(const SharedPtr &sp) {
            if(&sp == this) return *this; // we're setting to ourself, nothing changes.
            release();
            _data = sp._data;
            acquire();
            return *this;
        }
 
        SharedPtr &operator=(SharedPtr &&sp) noexcept {
            if(&sp == this) return *this;
            release();
            _data = sp._data;
            sp._data = nullptr;
            return *this;
        }
 
        void swap(SharedPtr &other) noexcept {
            std::swap(_data, other._data);
        }
 
        void clear() {
            release();
            _data = nullptr;
            return;
        }
 
        void detach() {
            // We only detach if not null and ref count > 1
            if(_data == nullptr || _data->_promeki_refct.value() < 2) return;
            T *copy = _data->_promeki_clone();
            release();
            setData(copy);
            // No need to acquire, since new Data object will have a refct of 1
            return;
        }
 
        bool isNull() const {
            return _data == nullptr;
        }
 
        bool isValid() const {
            return _data != nullptr;
        }
 
        explicit operator bool() const {
            return _data != nullptr;
        }
 
        bool operator==(const SharedPtr &other) const {
            return _data == other._data;
        }
 
        bool operator!=(const SharedPtr &other) const {
            return _data != other._data;
        }
 
        bool operator==(std::nullptr_t) const {
            return _data == nullptr;
        }
 
        bool operator!=(std::nullptr_t) const {
            return _data != nullptr;
        }
 
        int referenceCount() const {
            return _data == nullptr ? 0 : _data->_promeki_refct.value();
        }
 
        const T *ptr() const {
            assert(_data != nullptr);
            if constexpr (IsSharedObject<T>::value) {
                return _data;
            } else {
                return _data->object();
            }
        }
 
        T *modify() {
            assert(_data != nullptr);
            if constexpr (CopyOnWrite) detach();
            if constexpr (IsSharedObject<T>::value) {
                return _data;
            } else {
                return _data->object();
            }
        }
 
        const T *operator->() const {
            return ptr();
        }
 
        const T &operator*() const {
            return *ptr();
        }
 
    private:
        ST *_data = nullptr;
 
        // This function assumes you've already assigned _data to the Data you'd like to acquire
        void acquire() {
            if(_data == nullptr) return;
            _data->_promeki_refct.inc();
            return;
        }
 
        // This function releases _data, and if the reference count has dropped to zero, deletes it
        // however it does not change _data so it will be stale after calling this function.
        // This assumes you know this and are about to change _data (i.e. in a swap situation)
        void release() {
            if(_data == nullptr) return;
            if(_data->_promeki_refct.dec()) delete _data;
            return;
        }
 
        constexpr void setData(T *obj) {
            if constexpr (IsSharedObject<T>::value) {
                _data = obj;
            } else {
                _data = new ST(obj);
            }
            return;
        }
 
};
 
 
PROMEKI_NAMESPACE_END