intrusive_ptr.h

Go to the documentation of this file.

// Copyright 2025 owent
// Created by owent on 2017-05-18
 
#pragma once
 
// clang-format off
#include <libcopp/utils/config/stl_include_prefix.h>  // NOLINT(build/include_order)
// clang-format on
#include <assert.h>
#include <cstddef>
#include <memory>
#include <ostream>
 
#ifdef __cpp_impl_three_way_comparison
#  include <compare>
#endif
// clang-format off
#include <libcopp/utils/config/stl_include_suffix.h>  // NOLINT(build/include_order)
// clang-format on
 
#include <libcopp/utils/config/compile_optimize.h>
#include <libcopp/utils/config/libcopp_build_features.h>
 
LIBCOPP_COPP_NAMESPACE_BEGIN
namespace memory {
//
//  intrusive_ptr
//
//  A smart pointer that uses intrusive reference counting.
//
//  Relies on unqualified calls to
//
//      void intrusive_ptr_add_ref(T * p);
//      void intrusive_ptr_release(T * p);
//
//          (p != nullptr)
//
//  The object is responsible for destroying itself.
//
 
template <typename T>
class intrusive_ptr {
 public:
  using self_type = intrusive_ptr<T>;
  using element_type = T;
 
  constexpr intrusive_ptr() noexcept : px(nullptr) {}
 
  intrusive_ptr(T *p, bool add_ref = true) : px(p) {
    if (px != nullptr && add_ref) {
      intrusive_ptr_add_ref(px);
    }
  }
  intrusive_ptr(T *p, bool add_ref = true) : px(p) {…}
 
  template <typename U>
  intrusive_ptr(intrusive_ptr<U> const &rhs,
                typename std::enable_if<std::is_convertible<U *, T *>::value>::type * = nullptr)
      : px(rhs.get()) {
    if (px != nullptr) {
      intrusive_ptr_add_ref(px);
    }
  }
  intrusive_ptr(intrusive_ptr<U> const &rhs, {…}
 
  intrusive_ptr(self_type const &rhs) : px(rhs.px) {
    if (px != nullptr) {
      intrusive_ptr_add_ref(px);
    }
  }
  intrusive_ptr(self_type const &rhs) : px(rhs.px) {…}
 
  ~intrusive_ptr() {
    if (px != nullptr) {
      intrusive_ptr_release(px);
    }
  }
  ~intrusive_ptr() {…}
 
  template <typename U>
  friend class intrusive_ptr;
 
  template <typename U>
  intrusive_ptr &operator=(intrusive_ptr<U> const &rhs) {
    self_type(rhs).swap(*this);
    return *this;
  }
  intrusive_ptr &operator=(intrusive_ptr<U> const &rhs) {…}
 
  // Move support
  intrusive_ptr(self_type &&rhs) noexcept : px(rhs.px) { rhs.px = nullptr; }
 
  self_type &operator=(self_type &&rhs) noexcept {
    self_type(static_cast<self_type &&>(rhs)).swap(*this);
    return *this;
  }
  self_type &operator=(self_type &&rhs) noexcept {…}
 
  template <typename U>
  intrusive_ptr(intrusive_ptr<U> &&rhs,
                typename std::enable_if<std::is_convertible<U *, T *>::value>::type * = nullptr) noexcept
      : px(rhs.px) {
    rhs.px = nullptr;
  }
  intrusive_ptr(intrusive_ptr<U> &&rhs, {…}
 
  template <typename U, typename Deleter>
  self_type &operator=(std::unique_ptr<U, Deleter> &&rhs) {
    self_type(rhs.release()).swap(*this);
    return *this;
  }
  self_type &operator=(std::unique_ptr<U, Deleter> &&rhs) {…}
 
  self_type &operator=(self_type const &rhs) {
    self_type(rhs).swap(*this);
    return *this;
  }
  self_type &operator=(self_type const &rhs) {…}
 
  inline void reset() noexcept { self_type().swap(*this); }
 
  inline void reset(element_type *rhs) { self_type(rhs).swap(*this); }
 
  inline void reset(element_type *rhs, bool add_ref) { self_type(rhs, add_ref).swap(*this); }
 
  inline element_type *get() const noexcept { return px; }
 
  inline element_type *detach() noexcept {
    element_type *ret = px;
    px = nullptr;
    return ret;
  }
  inline element_type *detach() noexcept {…}
 
  inline element_type &operator*() const {
    assert(px != 0);
    return *px;
  }
  inline element_type &operator*() const  {…}
 
  inline element_type *operator->() const {
    assert(px != 0);
    return px;
  }
  inline element_type *operator->() const  {…}
 
  // implicit conversion to "bool"
  inline operator bool() const noexcept { return px != nullptr; }
  // operator! is redundant, but some compilers need it
  inline bool operator!() const noexcept { return px == nullptr; }
 
  inline void swap(intrusive_ptr &rhs) noexcept {
    element_type *tmp = px;
    px = rhs.px;
    rhs.px = tmp;
  }
  inline void swap(intrusive_ptr &rhs) noexcept {…}
 
 private:
  element_type *px;
};
class intrusive_ptr {…};
 
template <typename T, typename U>
inline bool operator==(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {
  return a.get() == b.get();
}
inline bool operator==(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator==(intrusive_ptr<T> const &a, U *b) noexcept {
  return a.get() == b;
}
inline bool operator==(intrusive_ptr<T> const &a, U *b) noexcept {…}
 
template <typename T, typename U>
inline bool operator==(T *a, intrusive_ptr<U> const &b) noexcept {
  return a == b.get();
}
inline bool operator==(T *a, intrusive_ptr<U> const &b) noexcept {…}
 
#ifdef __cpp_impl_three_way_comparison
template <typename T, typename U>
inline std::strong_ordering operator<=>(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {
  return a.get() <=> b.get();
}
 
template <typename T, typename U>
inline std::strong_ordering operator<=>(intrusive_ptr<T> const &a, U *b) noexcept {
  return a.get() <=> b;
}
 
template <typename T, typename U>
inline std::strong_ordering operator<=>(T *a, intrusive_ptr<U> const &b) noexcept {
  return a <=> b.get();
}
#else
template <typename T, typename U>
inline bool operator!=(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {
  return a.get() != b.get();
}
inline bool operator!=(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator!=(intrusive_ptr<T> const &a, U *b) noexcept {
  return a.get() != b;
}
inline bool operator!=(intrusive_ptr<T> const &a, U *b) noexcept {…}
 
template <typename T, typename U>
inline bool operator!=(T *a, intrusive_ptr<U> const &b) noexcept {
  return a != b.get();
}
inline bool operator!=(T *a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator<(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {
  return a.get() < b.get();
}
inline bool operator<(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator<(intrusive_ptr<T> const &a, U *b) noexcept {
  return a.get() < b;
}
inline bool operator<(intrusive_ptr<T> const &a, U *b) noexcept {…}
 
template <typename T, typename U>
inline bool operator<(T *a, intrusive_ptr<U> const &b) noexcept {
  return a < b.get();
}
inline bool operator<(T *a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator<=(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {
  return a.get() <= b.get();
}
inline bool operator<=(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator<=(intrusive_ptr<T> const &a, U *b) noexcept {
  return a.get() <= b;
}
inline bool operator<=(intrusive_ptr<T> const &a, U *b) noexcept {…}
 
template <typename T, typename U>
inline bool operator<=(T *a, intrusive_ptr<U> const &b) noexcept {
  return a <= b.get();
}
inline bool operator<=(T *a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator>(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {
  return a.get() > b.get();
}
inline bool operator>(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator>(intrusive_ptr<T> const &a, U *b) noexcept {
  return a.get() > b;
}
inline bool operator>(intrusive_ptr<T> const &a, U *b) noexcept {…}
 
template <typename T, typename U>
inline bool operator>(T *a, intrusive_ptr<U> const &b) noexcept {
  return a > b.get();
}
inline bool operator>(T *a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator>=(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {
  return a.get() >= b.get();
}
inline bool operator>=(intrusive_ptr<T> const &a, intrusive_ptr<U> const &b) noexcept {…}
 
template <typename T, typename U>
inline bool operator>=(intrusive_ptr<T> const &a, U *b) noexcept {
  return a.get() >= b;
}
inline bool operator>=(intrusive_ptr<T> const &a, U *b) noexcept {…}
 
template <typename T, typename U>
inline bool operator>=(T *a, intrusive_ptr<U> const &b) noexcept {
  return a >= b.get();
}
inline bool operator>=(T *a, intrusive_ptr<U> const &b) noexcept {…}
 
#endif
 
template <typename T>
inline bool operator==(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {
  return p.get() == nullptr;
}
inline bool operator==(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {…}
 
template <typename T>
inline bool operator==(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {
  return p.get() == nullptr;
}
inline bool operator==(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {…}
 
#ifdef __cpp_impl_three_way_comparison
template <typename T>
inline std::strong_ordering operator<=>(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {
  return p.get() <=> nullptr;
}
 
template <typename T>
inline std::strong_ordering operator<=>(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {
  return p.get() <=> nullptr;
}
#else
template <typename T>
inline bool operator!=(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {
  return p.get() != nullptr;
}
inline bool operator!=(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {…}
 
template <typename T>
inline bool operator!=(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {
  return p.get() != nullptr;
}
inline bool operator!=(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {…}
 
template <typename T>
inline bool operator<(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {
  return p.get() < nullptr;
}
inline bool operator<(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {…}
 
template <typename T>
inline bool operator<(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {
  return p.get() < nullptr;
}
inline bool operator<(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {…}
 
template <typename T>
inline bool operator<=(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {
  return p.get() <= nullptr;
}
inline bool operator<=(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {…}
 
template <typename T>
inline bool operator<=(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {
  return p.get() <= nullptr;
}
inline bool operator<=(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {…}
 
template <typename T>
inline bool operator>(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {
  return p.get() > nullptr;
}
inline bool operator>(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {…}
 
template <typename T>
inline bool operator>(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {
  return p.get() > nullptr;
}
inline bool operator>(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {…}
 
template <typename T>
inline bool operator>=(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {
  return p.get() >= nullptr;
}
inline bool operator>=(intrusive_ptr<T> const &p, std::nullptr_t) noexcept {…}
 
template <typename T>
inline bool operator>=(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {
  return p.get() >= nullptr;
}
inline bool operator>=(std::nullptr_t, intrusive_ptr<T> const &p) noexcept {…}
#endif
 
template <typename T>
void swap(intrusive_ptr<T> &lhs, intrusive_ptr<T> &rhs) {
  lhs.swap(rhs);
}
void swap(intrusive_ptr<T> &lhs, intrusive_ptr<T> &rhs) {…}
 
// mem_fn support
 
template <typename T>
T *get_pointer(intrusive_ptr<T> const &p) {
  return p.get();
}
T *get_pointer(intrusive_ptr<T> const &p) {…}
 
template <typename T, typename U>
intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const &p) {
  return static_cast<T *>(p.get());
}
intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const &p) {…}
 
template <typename T, typename U>
intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const &p) {
  return const_cast<T *>(p.get());
}
intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const &p) {…}
 
#if defined(LIBCOPP_MACRO_ENABLE_RTTI) && LIBCOPP_MACRO_ENABLE_RTTI
template <typename T, typename U>
intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const &p) {
  return dynamic_cast<T *>(p.get());
}
#endif
 
// operator<<
template <typename E, typename T, typename Y>
std::basic_ostream<E, T> &operator<<(std::basic_ostream<E, T> &os, intrusive_ptr<Y> const &p) {
  os << p.get();
  return os;
}
}  // namespace memory
LIBCOPP_COPP_NAMESPACE_END
 
#if LIBCOPP_MACRO_ENABLE_MULTI_THREAD
#  define LIBCOPP_UTIL_INTRUSIVE_PTR_ATOMIC_TYPE LIBCOPP_COPP_NAMESPACE_ID::util::lock::atomic_int_type<size_t>
#else
#  define LIBCOPP_UTIL_INTRUSIVE_PTR_ATOMIC_TYPE            \
    LIBCOPP_COPP_NAMESPACE_ID::util::lock::atomic_int_type< \
        LIBCOPP_COPP_NAMESPACE_ID::util::lock::unsafe_int_type<size_t> >
#  define LIBCOPP_UTIL_INTRUSIVE_PTR_ATOMIC_TYPE            \ …
#endif
 
#define LIBCOPP_UTIL_INTRUSIVE_PTR_REF_MEMBER_DECL(T)            \
                                                                 \
 private:                                                        \
  LIBCOPP_UTIL_INTRUSIVE_PTR_ATOMIC_TYPE intrusive_ref_counter_; \
  friend void intrusive_ptr_add_ref(T *p);                       \
  friend void intrusive_ptr_release(T *p);                       \
                                                                 \
 public:                                                         \
  const size_t use_count() const { return intrusive_ref_counter_.load(); }
#define LIBCOPP_UTIL_INTRUSIVE_PTR_REF_MEMBER_DECL(T)            \ …
 
#define LIBCOPP_UTIL_INTRUSIVE_PTR_REF_FN_DECL(T) \
  void intrusive_ptr_add_ref(T *p);               \
  void intrusive_ptr_release(T *p);
#define LIBCOPP_UTIL_INTRUSIVE_PTR_REF_FN_DECL(T) \ …
 
#define LIBCOPP_UTIL_INTRUSIVE_PTR_REF_MEMBER_INIT() this->intrusive_ref_counter_.store(0)
 
#define LIBCOPP_UTIL_INTRUSIVE_PTR_REF_FN_DEFI(T) \
  void intrusive_ptr_add_ref(T *p) {              \
    if (nullptr != p) {                           \
      ++p->intrusive_ref_counter_;                \
    }                                             \
  }                                               \
  void intrusive_ptr_release(T *p) {              \
    if (nullptr == p) {                           \
      return;                                     \
    }                                             \
    assert(p->intrusive_ref_counter_.load() > 0); \
    size_t ref = --p->intrusive_ref_counter_;     \
    if (0 == ref) {                               \
      delete p;                                   \
    }                                             \
  }
#define LIBCOPP_UTIL_INTRUSIVE_PTR_REF_FN_DEFI(T) \ …