sharedptr.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cassert>
#include <cstdlib>
#include <type_traits>
#include <typeinfo>
#include <utility>
#include <promeki/atomic.h>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T> T *promekiCloneOrAbort(const T *self) {
        if constexpr (std::is_copy_constructible_v<T>) {
                return new T(*self);
        } else {
                (void)self;
                std::abort();
        }
}
 
#define PROMEKI_SHARED_BASE(BASE)                                                                                      \
public:                                                                                                                \
        RefCount      _promeki_refct;                                                                                  \
        virtual BASE *_promeki_clone() const {                                                                         \
                return ::promeki::promekiCloneOrAbort<BASE>(this);                                                     \
        }
 
#define PROMEKI_SHARED_DERIVED(DERIVED)                                                                                \
public:                                                                                                                \
        DERIVED *_promeki_clone() const override {                                                                     \
                return ::promeki::promekiCloneOrAbort<DERIVED>(this);                                                  \
        }
 
#define PROMEKI_SHARED_ABSTRACT(INTERMEDIATE)                                                                          \
public:                                                                                                                \
        INTERMEDIATE *_promeki_clone() const override = 0;
 
#define PROMEKI_SHARED_FINAL(TYPE)                                                                                     \
public:                                                                                                                \
        RefCount _promeki_refct;                                                                                       \
        TYPE    *_promeki_clone() const {                                                                              \
                return ::promeki::promekiCloneOrAbort<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, MemoryOrder::Relaxed);
                        return *this;
                }
 
                void inc() {
                        if (v.load(MemoryOrder::Relaxed) >= Immortal) return;
                        v.fetchAndAdd(1, MemoryOrder::Relaxed);
                        return;
                }
 
                bool dec() {
                        if (v.load(MemoryOrder::Relaxed) >= Immortal) return false;
                        return v.fetchAndSub(1, MemoryOrder::AcqRel) == 1;
                }
 
                int value() const { return v.load(MemoryOrder::Relaxed); }
 
                bool isImmortal() const { return v.load(MemoryOrder::Relaxed) >= Immortal; }
 
                void setImmortal() { v.store(Immortal, MemoryOrder::Relaxed); }
 
        private:
                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:
                // All SharedPtr instantiations are friends of each other so the
                // upcast/downcast helpers can reach the private _data pointer
                // across type boundaries.
                template <typename OT, bool OCoW, typename OST> friend class SharedPtr;
 
                // sharedPointerCast needs access to _data for the dynamic_cast
                // round-trip; befriend every instantiation of the free function.
                template <typename DerivedT, typename BaseT, bool CoWT, typename STT>
                friend SharedPtr<DerivedT, CoWT, DerivedT> sharedPointerCast(const SharedPtr<BaseT, CoWT, STT> &sp);
 
                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; }
 
                template <typename U, bool UCoW, typename UST,
                          typename = std::enable_if_t<std::is_base_of_v<T, U> && !std::is_same_v<T, U> &&
                                                      IsSharedObject<T>::value && IsSharedObject<U>::value &&
                                                      std::is_same_v<UST, U>>>
                SharedPtr(const SharedPtr<U, UCoW, UST> &sp) : _data(sp._data) {
                        acquire();
                }
 
                template <typename U, bool UCoW, typename UST,
                          typename = std::enable_if_t<std::is_base_of_v<T, U> && !std::is_same_v<T, U> &&
                                                      IsSharedObject<T>::value && IsSharedObject<U>::value &&
                                                      std::is_same_v<UST, U>>>
                SharedPtr(SharedPtr<U, UCoW, UST> &&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;
                }
};
 
template <typename Derived, typename Base, bool CoW, typename ST>
SharedPtr<Derived, CoW, Derived> sharedPointerCast(const SharedPtr<Base, CoW, ST> &sp) {
        static_assert(IsSharedObject<Base>::value, "sharedPointerCast requires native shared objects");
        static_assert(IsSharedObject<Derived>::value, "sharedPointerCast requires native shared objects");
        static_assert(std::is_base_of_v<Base, Derived>, "Derived must publicly derive from Base");
        SharedPtr<Derived, CoW, Derived> result;
        if (sp.isNull()) return result;
        Derived *d = dynamic_cast<Derived *>(sp._data);
        if (d == nullptr) return result;
        result._data = d;
        result._data->_promeki_refct.inc();
        return result;
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE