IntrusivePointer.h

#pragma once
 
#include <concepts>
#include <cstdint>
#include <type_traits>
#include <utility>
 
namespace xrpl {
 
//------------------------------------------------------------------------------
 
struct StaticCastTagSharedIntrusive
{
};
 
struct DynamicCastTagSharedIntrusive
{
};
 
struct SharedIntrusiveAdoptIncrementStrongTag
{
};
 
struct SharedIntrusiveAdoptNoIncrementTag
{
};
 
//------------------------------------------------------------------------------
//
 
template <class T>
concept CAdoptTag =
    std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> || std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
 
//------------------------------------------------------------------------------
 
template <class T>
class SharedIntrusive
{
public:
    SharedIntrusive() = default;
 
    template <CAdoptTag TAdoptTag>
    SharedIntrusive(T* p, TAdoptTag) noexcept;
 
    SharedIntrusive(SharedIntrusive const& rhs);
 
    template <class TT>
    // TODO: convertible_to isn't quite right. That include a static castable.
    // Find the right concept.
        requires std::convertible_to<TT*, T*>
    SharedIntrusive(SharedIntrusive<TT> const& rhs);
 
    SharedIntrusive(SharedIntrusive&& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedIntrusive(SharedIntrusive<TT>&& rhs);
 
    SharedIntrusive&
    operator=(SharedIntrusive const& rhs);
 
    bool
    operator!=(std::nullptr_t) const;
 
    bool
    operator==(std::nullptr_t) const;
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedIntrusive&
    operator=(SharedIntrusive<TT> const& rhs);
 
    SharedIntrusive&
    operator=(SharedIntrusive&& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedIntrusive&
    operator=(SharedIntrusive<TT>&& rhs);
 
    template <CAdoptTag TAdoptTag = SharedIntrusiveAdoptIncrementStrongTag>
    void
    adopt(T* p);
 
    ~SharedIntrusive();
 
    template <class TT>
    SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs);
 
    template <class TT>
    SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
 
    template <class TT>
    SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs);
 
    template <class TT>
    SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
 
    T&
    operator*() const noexcept;
 
    T*
    operator->() const noexcept;
 
    explicit
    operator bool() const noexcept;
 
    void
    reset();
 
    T*
    get() const;
 
    std::size_t
    use_count() const;
 
    template <class TT, class... Args>
    friend SharedIntrusive<TT>
    make_SharedIntrusive(Args&&... args);
 
    template <class TT>
    friend class SharedIntrusive;
 
    template <class TT>
    friend class SharedWeakUnion;
 
    template <class TT>
    friend class WeakIntrusive;
 
private:
    T*
    unsafeGetRawPtr() const;
 
    void
    unsafeReleaseAndStore(T* next);
 
    void
    unsafeSetRawPtr(T* p);
 
    T*
    unsafeExchange(T* p);
 
    T* ptr_{nullptr};
};
 
//------------------------------------------------------------------------------
 
template <class T>
class WeakIntrusive
{
public:
    WeakIntrusive() = default;
 
    WeakIntrusive(WeakIntrusive const& rhs);
 
    WeakIntrusive(WeakIntrusive&& rhs);
 
    WeakIntrusive(SharedIntrusive<T> const& rhs);
 
    // There is no move constructor from a strong intrusive ptr because
    // moving would be move expensive than copying in this case (the strong
    // ref would need to be decremented)
    WeakIntrusive(SharedIntrusive<T> const&& rhs) = delete;
 
    // Since there are no current use cases for copy assignment in
    // WeakIntrusive, we delete this operator to simplify the implementation. If
    // a need arises in the future, we can reintroduce it with proper
    // consideration."
    WeakIntrusive&
    operator=(WeakIntrusive const&) = delete;
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    WeakIntrusive&
    operator=(SharedIntrusive<TT> const& rhs);
 
    void
    adopt(T* ptr);
 
    ~WeakIntrusive();
 
    SharedIntrusive<T>
    lock() const;
 
    bool
    expired() const;
 
    void
    reset();
 
private:
    T* ptr_ = nullptr;
 
    void
    unsafeReleaseNoStore();
};
 
//------------------------------------------------------------------------------
 
template <class T>
class SharedWeakUnion
{
    // Tagged pointer. Low bit determines if this is a strong or a weak
    // pointer. The low bit must be masked to zero when converting back to a
    // pointer. If the low bit is '1', this is a weak pointer.
    static_assert(alignof(T) >= 2, "Bad alignment: Combo pointer requires low bit to be zero");
 
public:
    SharedWeakUnion() = default;
 
    SharedWeakUnion(SharedWeakUnion const& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakUnion(SharedIntrusive<TT> const& rhs);
 
    SharedWeakUnion(SharedWeakUnion&& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakUnion(SharedIntrusive<TT>&& rhs);
 
    SharedWeakUnion&
    operator=(SharedWeakUnion const& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakUnion&
    operator=(SharedIntrusive<TT> const& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakUnion&
    operator=(SharedIntrusive<TT>&& rhs);
 
    ~SharedWeakUnion();
 
    SharedIntrusive<T>
    getStrong() const;
 
    explicit
    operator bool() const noexcept;
 
    void
    reset();
 
    T*
    get() const;
 
    std::size_t
    use_count() const;
 
    bool
    expired() const;
 
    SharedIntrusive<T>
    lock() const;
 
    bool
    isStrong() const;
 
    bool
    isWeak() const;
 
    bool
    convertToStrong();
 
    bool
    convertToWeak();
 
private:
    // Tagged pointer. Low bit determines if this is a strong or a weak
    // pointer. The low bit must be masked to zero when converting back to a
    // pointer. If the low bit is '1', this is a weak pointer.
    std::uintptr_t tp_{0};
    static constexpr std::uintptr_t tagMask = 1;
    static constexpr std::uintptr_t ptrMask = ~tagMask;
 
private:
    T*
    unsafeGetRawPtr() const;
 
    enum class RefStrength { strong, weak };
    void
    unsafeSetRawPtr(T* p, RefStrength rs);
 
    void unsafeSetRawPtr(std::nullptr_t);
 
    void
    unsafeReleaseNoStore();
};
 
//------------------------------------------------------------------------------
 
template <class TT, class... Args>
SharedIntrusive<TT>
make_SharedIntrusive(Args&&... args)
{
    auto p = new TT(std::forward<Args>(args)...);
 
    static_assert(
        noexcept(SharedIntrusive<TT>(std::declval<TT*>(), std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
        "SharedIntrusive constructor should not throw or this can leak "
        "memory");
 
    return SharedIntrusive<TT>(p, SharedIntrusiveAdoptNoIncrementTag{});
}
 
//------------------------------------------------------------------------------
 
namespace intr_ptr {
template <class T>
using SharedPtr = SharedIntrusive<T>;
 
template <class T>
using WeakPtr = WeakIntrusive<T>;
 
template <class T>
using SharedWeakUnionPtr = SharedWeakUnion<T>;
 
template <class T, class... A>
SharedPtr<T>
make_shared(A&&... args)
{
    return make_SharedIntrusive<T>(std::forward<A>(args)...);
}
 
template <class T, class TT>
SharedPtr<T>
static_pointer_cast(TT const& v)
{
    return SharedPtr<T>(StaticCastTagSharedIntrusive{}, v);
}
 
template <class T, class TT>
SharedPtr<T>
dynamic_pointer_cast(TT const& v)
{
    return SharedPtr<T>(DynamicCastTagSharedIntrusive{}, v);
}
}  // namespace intr_ptr
}  // namespace xrpl