intrusive_shared_ptr.hpp

// Copyright (c) Sleipnir contributors
 
#pragma once
 
#include <concepts>
#include <cstddef>
#include <memory>
#include <utility>
 
namespace slp {
 
template <typename T>
class IntrusiveSharedPtr {
 public:
  template <typename>
  friend class IntrusiveSharedPtr;
 
  constexpr IntrusiveSharedPtr() noexcept = default;
 
  constexpr IntrusiveSharedPtr(std::nullptr_t) noexcept {}  // NOLINT
 
  explicit constexpr IntrusiveSharedPtr(T* ptr) noexcept : m_ptr{ptr} {
    if (m_ptr != nullptr) {
      inc_ref_count(m_ptr);
    }
  }
 
  constexpr ~IntrusiveSharedPtr() {
    if (m_ptr != nullptr) {
      dec_ref_count(m_ptr);
    }
  }
 
  constexpr IntrusiveSharedPtr(const IntrusiveSharedPtr<T>& rhs) noexcept
      : m_ptr{rhs.m_ptr} {
    if (m_ptr != nullptr) {
      inc_ref_count(m_ptr);
    }
  }
 
  template <typename U>
    requires(!std::same_as<T, U> && std::convertible_to<U*, T*>)
  constexpr IntrusiveSharedPtr(  // NOLINT
      const IntrusiveSharedPtr<U>& rhs) noexcept
      : m_ptr{rhs.m_ptr} {
    if (m_ptr != nullptr) {
      inc_ref_count(m_ptr);
    }
  }
 
  constexpr IntrusiveSharedPtr<T>& operator=(  // NOLINT
      const IntrusiveSharedPtr<T>& rhs) noexcept {
    if (m_ptr == rhs.m_ptr) {
      return *this;
    }
 
    if (m_ptr != nullptr) {
      dec_ref_count(m_ptr);
    }
 
    m_ptr = rhs.m_ptr;
 
    if (m_ptr != nullptr) {
      inc_ref_count(m_ptr);
    }
 
    return *this;
  }
 
  template <typename U>
    requires(!std::same_as<T, U> && std::convertible_to<U*, T*>)
  constexpr IntrusiveSharedPtr<T>& operator=(  // NOLINT
      const IntrusiveSharedPtr<U>& rhs) noexcept {
    if (m_ptr == rhs.m_ptr) {
      return *this;
    }
 
    if (m_ptr != nullptr) {
      dec_ref_count(m_ptr);
    }
 
    m_ptr = rhs.m_ptr;
 
    if (m_ptr != nullptr) {
      inc_ref_count(m_ptr);
    }
 
    return *this;
  }
 
  constexpr IntrusiveSharedPtr(IntrusiveSharedPtr<T>&& rhs) noexcept
      : m_ptr{std::exchange(rhs.m_ptr, nullptr)} {}
 
  template <typename U>
    requires(!std::same_as<T, U> && std::convertible_to<U*, T*>)
  constexpr IntrusiveSharedPtr(  // NOLINT
      IntrusiveSharedPtr<U>&& rhs) noexcept
      : m_ptr{std::exchange(rhs.m_ptr, nullptr)} {}
 
  constexpr IntrusiveSharedPtr<T>& operator=(
      IntrusiveSharedPtr<T>&& rhs) noexcept {
    if (m_ptr == rhs.m_ptr) {
      return *this;
    }
 
    std::swap(m_ptr, rhs.m_ptr);
 
    return *this;
  }
 
  template <typename U>
    requires(!std::same_as<T, U> && std::convertible_to<U*, T*>)
  constexpr IntrusiveSharedPtr<T>& operator=(
      IntrusiveSharedPtr<U>&& rhs) noexcept {
    if (m_ptr == rhs.m_ptr) {
      return *this;
    }
 
    std::swap(m_ptr, rhs.m_ptr);
 
    return *this;
  }
 
  constexpr T* get() const noexcept { return m_ptr; }
 
  constexpr T& operator*() const noexcept { return *m_ptr; }
 
  constexpr T* operator->() const noexcept { return m_ptr; }
 
  explicit constexpr operator bool() const noexcept { return m_ptr != nullptr; }
 
  friend constexpr bool operator==(const IntrusiveSharedPtr<T>& lhs,
                                   const IntrusiveSharedPtr<T>& rhs) noexcept {
    return lhs.m_ptr == rhs.m_ptr;
  }
 
  friend constexpr bool operator!=(const IntrusiveSharedPtr<T>& lhs,
                                   const IntrusiveSharedPtr<T>& rhs) noexcept {
    return lhs.m_ptr != rhs.m_ptr;
  }
 
  friend constexpr bool operator==(const IntrusiveSharedPtr<T>& lhs,
                                   std::nullptr_t) noexcept {
    return lhs.m_ptr == nullptr;
  }
 
  friend constexpr bool operator==(std::nullptr_t,
                                   const IntrusiveSharedPtr<T>& rhs) noexcept {
    return nullptr == rhs.m_ptr;
  }
 
  friend constexpr bool operator!=(const IntrusiveSharedPtr<T>& lhs,
                                   std::nullptr_t) noexcept {
    return lhs.m_ptr != nullptr;
  }
 
  friend constexpr bool operator!=(std::nullptr_t,
                                   const IntrusiveSharedPtr<T>& rhs) noexcept {
    return nullptr != rhs.m_ptr;
  }
 
 private:
  T* m_ptr = nullptr;
};
 
template <typename T, typename... Args>
IntrusiveSharedPtr<T> make_intrusive_shared(Args&&... args) {
  return IntrusiveSharedPtr<T>{new T(std::forward<Args>(args)...)};
}
 
template <typename T, typename Alloc, typename... Args>
IntrusiveSharedPtr<T> allocate_intrusive_shared(Alloc alloc, Args&&... args) {
  auto ptr = std::allocator_traits<Alloc>::allocate(alloc, sizeof(T));
  std::allocator_traits<Alloc>::construct(alloc, ptr,
                                          std::forward<Args>(args)...);
  return IntrusiveSharedPtr<T>{ptr};
}
 
}  // namespace slp