IntrusivePointer.h

#pragma once
 
#include <functional>
#include <type_traits>
#include <utility>
 
namespace CesiumUtility {
 
template <class T> class IntrusivePointer final {
public:
  IntrusivePointer(T* p = nullptr) noexcept : _p(p) { this->addReference(); }
 
  IntrusivePointer(const IntrusivePointer<T>& rhs) noexcept : _p(rhs._p) {
    this->addReference();
  }
 
  template <class U>
  IntrusivePointer(const IntrusivePointer<U>& rhs) noexcept : _p(rhs._p) {
    this->addReference();
  }
 
  IntrusivePointer(IntrusivePointer<T>&& rhs) noexcept
      : _p(std::exchange(rhs._p, nullptr)) {
    // Reference count is unchanged
  }
 
  template <class U>
  IntrusivePointer(IntrusivePointer<U>&& rhs) noexcept
      : _p(std::exchange(rhs._p, nullptr)) {
    // Reference count is unchanged
  }
 
  ~IntrusivePointer() noexcept { this->releaseReference(); }
 
  template <typename... ConstructorArgumentTypes>
  T& emplace(ConstructorArgumentTypes&&... constructorArguments) {
    *this =
        new T(std::forward<ConstructorArgumentTypes>(constructorArguments)...);
    return *this->get();
  }
 
  void reset() { *this = nullptr; }
 
  // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
  IntrusivePointer& operator=(const IntrusivePointer& rhs) noexcept {
    if (*this != rhs) {
      // addReference the new pointer before releaseReference'ing the old.
      T* pOld = this->_p;
      this->_p = rhs._p;
      addReference();
 
      if (pOld) {
        pOld->releaseReference();
      }
    }
 
    return *this;
  }
 
  template <class U>
  IntrusivePointer& operator=(const IntrusivePointer<U>& rhs) noexcept {
    if (*this != rhs) {
      // addReference the new pointer before releaseReference'ing the old.
      T* pOld = this->_p;
      this->_p = rhs._p;
      addReference();
 
      if (pOld) {
        pOld->releaseReference();
      }
    }
 
    return *this;
  }
 
  IntrusivePointer& operator=(IntrusivePointer&& rhs) noexcept {
    if (this->_p != rhs._p) {
      std::swap(this->_p, rhs._p);
    }
 
    return *this;
  }
 
  IntrusivePointer& operator=(T* p) noexcept {
    if (this->_p != p) {
      // addReference the new pointer before releaseReference'ing the old.
      T* pOld = this->_p;
      this->_p = p;
      addReference();
 
      if (pOld) {
        pOld->releaseReference();
      }
    }
 
    return *this;
  }
 
  T& operator*() const noexcept { return *this->_p; }
 
  T* operator->() const noexcept { return this->_p; }
 
  explicit operator bool() const noexcept { return this->_p != nullptr; }
 
  T* get() const noexcept { return this->_p; }
 
  bool operator==(const IntrusivePointer<T>& rhs) const noexcept {
    return this->_p == rhs._p;
  }
 
  template <class U>
  bool operator==(const IntrusivePointer<U>& rhs) const noexcept {
    return this->_p == rhs._p;
  }
 
  bool operator!=(const IntrusivePointer<T>& rhs) const noexcept {
    return !(*this == rhs);
  }
 
  template <class U>
  bool operator!=(const IntrusivePointer<U>& rhs) const noexcept {
    return !(*this == rhs);
  }
 
  bool operator==(const T* pRhs) const noexcept { return this->_p == pRhs; }
 
  bool operator!=(const T* pRhs) const noexcept { return !(*this == pRhs); }
 
private:
  void addReference() noexcept {
    if (this->_p) {
      this->_p->addReference();
    }
  }
 
  void releaseReference() noexcept {
    if (this->_p) {
      this->_p->releaseReference();
    }
  }
 
  T* _p;
  template <typename U> friend class IntrusivePointer;
};
 
template <typename T, typename U>
IntrusivePointer<T>
const_intrusive_cast(const IntrusivePointer<U>& p) noexcept {
  return IntrusivePointer<T>(const_cast<T*>(p.get()));
}
 
} // namespace CesiumUtility
 
template <typename T> struct std::hash<CesiumUtility::IntrusivePointer<T>> {
  std::size_t
  operator()(const CesiumUtility::IntrusivePointer<T>& key) const noexcept {
    std::hash<T*> hasher{};
    return hasher(key.get());
  }
};