ReferenceCounted.h

#pragma once
 
#include <CesiumUtility/Assert.h>
 
#include <atomic>
#include <cstdint>
 
#ifndef NDEBUG
#include <thread>
#endif
 
namespace CesiumUtility {
 
#ifndef NDEBUG
template <bool isThreadSafe> class ThreadIdHolder;
 
template <> class ThreadIdHolder<false> {
  ThreadIdHolder() : _threadID(std::this_thread::get_id()) {}
 
  std::thread::id _threadID;
 
  template <typename T, bool isThreadSafe> friend class ReferenceCounted;
};
 
template <> class ThreadIdHolder<true> {};
#endif
template <typename T, bool isThreadSafe = true>
class ReferenceCounted
#ifndef NDEBUG
    : public ThreadIdHolder<isThreadSafe>
#endif
{
public:
  ~ReferenceCounted() noexcept { CESIUM_ASSERT(this->_referenceCount == 0); }
 
  void addReference() const /*noexcept*/ {
#ifndef NDEBUG
    if constexpr (!isThreadSafe) {
      CESIUM_ASSERT(std::this_thread::get_id() == this->_threadID);
    }
#endif
 
    ++this->_referenceCount;
  }
 
  void releaseReference() const /*noexcept*/ {
#ifndef NDEBUG
    if constexpr (!isThreadSafe) {
      CESIUM_ASSERT(std::this_thread::get_id() == this->_threadID);
    }
#endif
 
    CESIUM_ASSERT(this->_referenceCount > 0);
    const int32_t references = --this->_referenceCount;
    if (references == 0) {
      delete static_cast<const T*>(this);
    }
  }
 
  std::int32_t getReferenceCount() const noexcept {
    return this->_referenceCount;
  }
 
private:
  ReferenceCounted() noexcept = default;
  friend T;
 
  using ThreadSafeCounter = std::atomic<std::int32_t>;
  using NonThreadSafeCounter = std::int32_t;
  using CounterType =
      std::conditional_t<isThreadSafe, ThreadSafeCounter, NonThreadSafeCounter>;
 
  mutable CounterType _referenceCount{0};
};
 
template <typename T>
using ReferenceCountedThreadSafe = ReferenceCounted<T, true>;
 
template <typename T>
using ReferenceCountedNonThreadSafe = ReferenceCounted<T, false>;
 
} // namespace CesiumUtility