SpartaSharedPointer.hpp

Go to the documentation of this file.

// <SpartaSharedPointer.hpp> -*- C++ -*-
 
#pragma once
 
#include <cinttypes>
#include <cassert>
#include <type_traits>
 
#include "sparta/utils/Utils.hpp"
#include "sparta/utils/MetaStructs.hpp"
#include "sparta/utils/SpartaSharedPointerBaseAllocator.hpp"
 
namespace sparta
{
    // Forward declarations
    template<class PointerT>
    class SpartaSharedPointerAllocator;
 
    template<class PointerT>
    class SpartaWeakPointer;
 
    template <class PointerT>
    class SpartaSharedPointer
    {
    public:
        template<class PointerT2>
        friend class SpartaSharedPointer;
 
    private:
        struct RefCount
        {
            RefCount(PointerT * _p, void * mem_block) :
                p(_p), mem_block(mem_block)
            {}
 
            explicit RefCount(PointerT * _p) :
                RefCount(_p, nullptr)
            {}
 
            // Small cleanup -- set to nullptr
            ~RefCount() { p = nullptr; }
 
            int32_t count   {1};
            int32_t wp_count{0}; // For weakpointers
            PointerT * p = nullptr;
            void     * mem_block = nullptr;
        };
 
    public:
        using element_type = PointerT;
 
        explicit SpartaSharedPointer(PointerT * p = nullptr) noexcept :
            ref_count_(p == nullptr ? nullptr : new RefCount(p))
        {}
 
        constexpr SpartaSharedPointer(std::nullptr_t) noexcept :
            ref_count_(nullptr)
        {}
 
        template<class PointerT2>
        SpartaSharedPointer(const SpartaSharedPointer<PointerT2>& orig) noexcept :
            ref_count_((SpartaSharedPointer<PointerT>::RefCount*)orig.ref_count_)
        {
            static_assert(std::is_base_of<PointerT, PointerT2>::value == true,
                "Only upcasting (derived class -> base class) of SpartaSharedPointer is supported!");
            static_assert(std::has_virtual_destructor<PointerT>::value == true,
                "Base class must have a virtual destructor defined to support upcasting!");
            if(SPARTA_EXPECT_TRUE(ref_count_ != nullptr)) {
                ++ref_count_->count;
            }
        }
 
        SpartaSharedPointer(const SpartaSharedPointer & orig) :
            ref_count_(orig.ref_count_)
        {
            if(SPARTA_EXPECT_TRUE(ref_count_ != nullptr)) {
                ++ref_count_->count;
            }
        }
 
        SpartaSharedPointer(SpartaSharedPointer && orig) :
            ref_count_(orig.ref_count_)
        {
            // DO NOT unlink.
            orig.ref_count_ = nullptr;
        }
 
        ~SpartaSharedPointer() {
            unlink_();
        }
 
        SpartaSharedPointer & operator=(const SpartaSharedPointer & orig)
        {
            sparta_assert(&orig != this);
            unlink_();
            ref_count_ = orig.ref_count_;
            if(SPARTA_EXPECT_TRUE(ref_count_ != nullptr)) {
                ++ref_count_->count;
            }
            return *this;
        }
 
        SpartaSharedPointer & operator=(SpartaSharedPointer && orig)
        {
            sparta_assert(&orig != this);
            unlink_();
            ref_count_ = orig.ref_count_;
            orig.ref_count_ = nullptr;
            return *this;
        }
 
        bool operator!() const {
            return (ref_count_ == nullptr) || (ref_count_->p == nullptr);
        }
 
        explicit operator bool() const {
            return (ref_count_ && (ref_count_->p == nullptr ? false : true));
        }
 
        PointerT * operator->() const {
            return (ref_count_ ? ref_count_->p : nullptr);
        }
 
        PointerT & operator*() const {
            sparta_assert(ref_count_ != nullptr, "This is a null SpartaSharedPointer");
            return *(ref_count_->p);
        }
 
        PointerT * get() const {
            return (ref_count_ ? ref_count_->p : nullptr);
        }
 
        void reset(PointerT * p = nullptr) {
            unlink_();
            ref_count_ = p == nullptr ? nullptr : new RefCount(p);
        }
 
        uint32_t use_count() const {
            if(SPARTA_EXPECT_TRUE(ref_count_ != nullptr)) {
                return ref_count_->p ? ref_count_->count : 0;
            }
            return 0;
        }
 
    private:
 
        static void releaseRefCount_(RefCount *& ref_count)
        {
            if(0 == ref_count->count) {
                // Make it go negative to show there are no
                // SpartaSharedPointer objects using this ref_count.
                // We can't set it to nullptr because it might be
                // allocated on the heap and we need to ensure all
                // SpartaWeakPointer objects are done with it too.
                //
                // This pointer needs to be set here to prevent a weak pointer
                // from being destructed and calling releaseObject_ in a cycle.
                --(ref_count->count);
 
                // Claim a weak-pointer reference on the block. This ensures
                // that no one else will delete the reference count block out
                // from under us higher up the call stack.
                ++ref_count->wp_count;
 
                BaseAllocator::MemBlockBase * memory_block =
                    static_cast<BaseAllocator::MemBlockBase *>(ref_count->mem_block);
 
                // These calls are dangerous! When we're destroying our
                // object, we may arrive at this point in the _same_ shared
                // pointer _recursively_ further up the call stack if the
                // pointed-to object contains a weak pointer that points back to
                // itself.
                if(SPARTA_EXPECT_TRUE(nullptr != memory_block)) {
                    memory_block->alloc->releaseObject_(memory_block);
                }
                else {
                    delete ref_count->p;
                    ref_count->p = nullptr;
                }
 
                // Release the weak-pointer reference that we claimed above. Now
                // we will proceed to release ref_count, and can rest assured
                // that no recursive call to weak-pointer destruction released
                // ref_count out from under us.
                --ref_count->wp_count;
            }
 
            if((0 >= ref_count->count) && (0 == ref_count->wp_count))
            {
                // Because we claimed the weak-pointer reference above, we can
                // ensure that we only make one pass through this block---even
                // if we destroy a weak pointer recursively, it will not try to
                // destroy this block.
                BaseAllocator::MemBlockBase * memory_block =
                    static_cast<BaseAllocator::MemBlockBase *>(ref_count->mem_block);
 
                if(SPARTA_EXPECT_TRUE(nullptr != memory_block)) {
                    memory_block->alloc->releaseBlock_(memory_block);
                }
                else {
                    delete ref_count;
                }
                ref_count = nullptr;
            }
        }
 
        void unlink_()
        {
            if(SPARTA_EXPECT_TRUE(ref_count_ != nullptr))
            {
                --ref_count_->count;
                releaseRefCount_(ref_count_);
            }
        }
 
        // Used by SpartaWeakPointer and Allocator.  weak_alloc is
        // true if from WP
        explicit SpartaSharedPointer(RefCount * cnt, const bool weak_ptr = false) :
            ref_count_(cnt)
        {
            if(weak_ptr && ref_count_) { ++ref_count_->count; }
        }
 
        RefCount * ref_count_ = nullptr;
 
        friend class SpartaSharedPointerAllocator<PointerT>;
        friend class SpartaWeakPointer<PointerT>;
 
        template<typename PtrT, typename... Args>
        friend SpartaSharedPointer<PtrT>
        allocate_sparta_shared_pointer(SpartaSharedPointerAllocator<PtrT> &, Args&&...args);
    };
 
 
    template<class PointerT>
    class SpartaWeakPointer
    {
    public:
        constexpr SpartaWeakPointer() noexcept = default;
 
        SpartaWeakPointer(const sparta::SpartaSharedPointer<PointerT> & sp) noexcept :
            wp_ref_cnt_(sp.ref_count_)
        {
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                ++(wp_ref_cnt_->wp_count);
            }
        }
 
        ~SpartaWeakPointer() {
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                --(wp_ref_cnt_->wp_count);
                SpartaSharedPointer<PointerT>::releaseRefCount_(wp_ref_cnt_);
                wp_ref_cnt_ = nullptr;
            }
        }
 
        SpartaWeakPointer(const SpartaWeakPointer & orig) :
            wp_ref_cnt_(orig.wp_ref_cnt_)
        {
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                ++(wp_ref_cnt_->wp_count);
            }
        }
 
        SpartaWeakPointer(SpartaWeakPointer &&orig) :
            wp_ref_cnt_(orig.wp_ref_cnt_)
        {
            orig.wp_ref_cnt_ = nullptr;
        }
 
        SpartaWeakPointer & operator=(const SpartaWeakPointer & orig)
        {
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                --(wp_ref_cnt_->wp_count);
                SpartaSharedPointer<PointerT>::releaseRefCount_(wp_ref_cnt_);
            }
            wp_ref_cnt_ = orig.wp_ref_cnt_;
 
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                ++(wp_ref_cnt_->wp_count);
            }
            return *this;
        }
 
        SpartaWeakPointer & operator=(SpartaWeakPointer && orig)
        {
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                --(wp_ref_cnt_->wp_count);
                SpartaSharedPointer<PointerT>::releaseRefCount_(wp_ref_cnt_);
            }
 
            wp_ref_cnt_ = orig.wp_ref_cnt_;
            orig.wp_ref_cnt_ = nullptr;
            return *this;
        }
 
        long use_count() const noexcept {
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                return (wp_ref_cnt_->count <= 0 ? 0 : wp_ref_cnt_->count);
            }
            return 0;
        }
 
        bool expired() const noexcept {
            if(SPARTA_EXPECT_TRUE(nullptr != wp_ref_cnt_)) {
                return wp_ref_cnt_->count <= 0;
            }
            return true;
        }
 
        SpartaSharedPointer<PointerT> lock() const noexcept {
            return SpartaSharedPointer<PointerT>(wp_ref_cnt_, true);
        }
 
    private:
        typename SpartaSharedPointer<PointerT>::RefCount * wp_ref_cnt_ = nullptr;
    };
 
 
    template<typename PtrT, typename Ptr2>
    bool operator==(const SpartaSharedPointer<PtrT>& ptr1, const SpartaSharedPointer<Ptr2>& ptr2) noexcept
    { return ptr1.get() == ptr2.get(); }
 
    template<typename PtrT>
    bool operator==(const SpartaSharedPointer<PtrT>& ptr1, std::nullptr_t) noexcept
    { return !ptr1; }
 
    template<typename PtrT>
    bool operator==(std::nullptr_t, const SpartaSharedPointer<PtrT>& ptr1) noexcept
    { return !ptr1; }
 
    template<typename PtrT, typename Ptr2>
    bool operator!=(const SpartaSharedPointer<PtrT>& ptr1, const SpartaSharedPointer<Ptr2>& ptr2) noexcept
    { return ptr1.get() != ptr2.get(); }
 
    template<typename PtrT>
    bool operator!=(const SpartaSharedPointer<PtrT>& ptr1, std::nullptr_t) noexcept
    { return (bool)ptr1; }
 
    template<typename PtrT>
    bool operator!=(std::nullptr_t, const SpartaSharedPointer<PtrT>& ptr1) noexcept
    { return (bool)ptr1; }
 
    template<typename PtrT>
    std::ostream& operator<<(std::ostream & os, const SpartaSharedPointer<PtrT> & p)
    {
        os << p.get();
        return os;
    }
 
} // sparta namespace
 
// Helper methods to determine pointer type and/or remove it
namespace MetaStruct {
 
    // Helper structs
    template<typename T>
    struct is_any_pointer<sparta::SpartaSharedPointer<T>> : public std::true_type {};
 
    template<typename T>
    struct is_any_pointer<sparta::SpartaSharedPointer<T> const> : public std::true_type {};
 
    template<typename T>
    struct is_any_pointer<sparta::SpartaSharedPointer<T> &> : public std::true_type {};
 
    template<typename T>
    struct is_any_pointer<sparta::SpartaSharedPointer<T> const &> : public std::true_type {};
 
    template<typename T>
    struct remove_any_pointer<sparta::SpartaSharedPointer<T>> { using type = T; };
 
    template<typename T>
    struct remove_any_pointer<sparta::SpartaSharedPointer<T> const> { using type = T; };
 
    template<typename T>
    struct remove_any_pointer<sparta::SpartaSharedPointer<T> &> { using type = T; };
 
    template<typename T>
    struct remove_any_pointer<sparta::SpartaSharedPointer<T> const &> { using type = T; };
}