intrusive_ptr.hpp

#pragma once
 
#include <utility>
 
namespace delpi {

template <class T>
class intrusive_ptr {
 public:
  typedef T element_type;  

  intrusive_ptr() : ptr_{nullptr} {}

  explicit intrusive_ptr(T* p, const bool add_ref = true) : ptr_{p} {
    if (ptr_ && add_ref) ptr_->AddRef();
  }

  intrusive_ptr(const intrusive_ptr& ip) : ptr_{ip.ptr_} {
    if (ptr_) ptr_->AddRef();
  }

  intrusive_ptr(intrusive_ptr&& ip) noexcept : ptr_{ip.ptr_} { ip.ptr_ = nullptr; }

  ~intrusive_ptr() {
    if (ptr_) ptr_->Release();
  }

  intrusive_ptr& operator=(const intrusive_ptr& ip) {
    intrusive_ptr{ip}.swap(*this);
    return *this;
  }

  intrusive_ptr& operator=(intrusive_ptr&& ip) noexcept {
    // NOLINTNEXTLINE(runtime/explicit) per C++ standard concept definition
    intrusive_ptr(static_cast<intrusive_ptr&&>(ip)).swap(*this);
    return *this;
  }

  intrusive_ptr& operator=(T* ptr) {
    intrusive_ptr{ptr}.swap(*this);
    return *this;
  }

  T& operator*() const { return *ptr_; }
  T* operator->() const { return ptr_; }
  [[nodiscard]] T* get() const { return ptr_; }

  void reset() { intrusive_ptr{}.swap(*this); }

  void swap(intrusive_ptr& ip) noexcept { std::swap(ptr_, ip.ptr_); }

   */
  void attach(T* ptr) {
    T* const temp_ptr = ptr_;
    ptr_ = ptr;
    if (temp_ptr) temp_ptr->Release();
  }

   */
  T* detach() {
    T* const pTemp = ptr_;
    ptr_ = nullptr;
    return pTemp;
  }
 
  typedef element_type* intrusive_ptr::* bool_;
  operator bool_() const noexcept { return ptr_ ? &intrusive_ptr::ptr_ : nullptr; }
  bool operator!() const { return ptr_ == nullptr; }
 
 protected:
  T* ptr_;  
};
 
}  // namespace delpi