IntrusivePointer.h

#pragma once
 
#include <concepts>
#include <cstddef>
#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);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
    SharedIntrusive&
    operator=(SharedIntrusive const& rhs);
 
    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);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)

    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();

    [[nodiscard]] T*
    get() const;

    [[nodiscard]] std::size_t
    useCount() const;
 
    template <class TT, class... Args>
    friend SharedIntrusive<TT>
    makeSharedIntrusive(Args&&... args);
 
    template <class TT>
    friend class SharedIntrusive;
 
    template <class TT>
    friend class SharedWeakUnion;
 
    template <class TT>
    friend class WeakIntrusive;
 
private:
    [[nodiscard]] 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;

    [[nodiscard]] 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);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
    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);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
    ~SharedWeakUnion();

    [[nodiscard]] SharedIntrusive<T>
    getStrong() const;

    explicit
    operator bool() const noexcept;

    void
    reset();

    [[nodiscard]] T*
    get() const;

    [[nodiscard]] std::size_t
    useCount() const;

    [[nodiscard]] bool
    expired() const;

    [[nodiscard]] SharedIntrusive<T>
    lock() const;

    [[nodiscard]] bool
    isStrong() const;

    [[nodiscard]] 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 kTagMask = 1;
    static constexpr std::uintptr_t kPtrMask = ~kTagMask;
 
private:
    [[nodiscard]] 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>
makeSharedIntrusive(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>
makeShared(A&&... args)
{
    return makeSharedIntrusive<T>(std::forward<A>(args)...);
}
 
template <class T, class TT>
SharedPtr<T>
staticPointerCast(TT const& v)
{
    return SharedPtr<T>(StaticCastTagSharedIntrusive{}, v);
}
 
template <class T, class TT>
SharedPtr<T>
dynamicPointerCast(TT const& v)
{
    return SharedPtr<T>(DynamicCastTagSharedIntrusive{}, v);
}
}  // namespace intr_ptr
}  // namespace xrpl