SharedAsset.h

#pragma once
 
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>
#include <CesiumUtility/IDepotOwningAsset.h>
#include <CesiumUtility/Library.h>
 
#include <atomic>
 
namespace CesiumAsync {
 
template <typename TAssetType, typename TAssetKey, typename TContext>
class SharedAssetDepot;
 
} // namespace CesiumAsync
 
namespace CesiumUtility {

template <typename T>
class CESIUMUTILITY_API SharedAsset : public CesiumUtility::ExtensibleObject {
public:
  void addReference() const noexcept { this->addReference(false); }

  void releaseReference() const noexcept { this->releaseReference(false); }

  const IDepotOwningAsset<T>* getDepot() const { return this->_pDepot; }

  IDepotOwningAsset<T>* getDepot() { return this->_pDepot; }
 
private:
  SharedAsset() = default;
  ~SharedAsset() { CESIUM_ASSERT(this->_referenceCount == 0); }

  SharedAsset(const SharedAsset& rhs)
      : ExtensibleObject(rhs), _referenceCount(0), _pDepot(nullptr) {}

  SharedAsset(SharedAsset&& rhs) noexcept
      : ExtensibleObject(std::move(rhs)),
        _referenceCount(0),
        _pDepot(nullptr) {}

  SharedAsset& operator=(const SharedAsset& rhs) noexcept {
    if (&rhs != this) {
      CesiumUtility::ExtensibleObject::operator=(rhs);
    }
    return *this;
  }

  SharedAsset& operator=(SharedAsset&& rhs) noexcept {
    if (&rhs != this) {
      CesiumUtility::ExtensibleObject::operator=(std::move(rhs));
    }
    return *this;
  }
 
private:
  void addReference(bool threadOwnsDepotLock) const noexcept {
    const int32_t prevReferences = this->_referenceCount++;
    if (this->_pDepot && prevReferences <= 0) {
      this->_pDepot->unmarkDeletionCandidate(
          *static_cast<const T*>(this),
          threadOwnsDepotLock);
    }
  }
 
  void releaseReference(bool threadOwnsDepotLock) const noexcept {
    CESIUM_ASSERT(this->_referenceCount > 0);
    const int32_t references = --this->_referenceCount;
    if (references == 0) {
      IDepotOwningAsset<T>* pDepot = this->_pDepot;
      if (pDepot) {
        // Let the depot manage this object's lifetime.
        pDepot->markDeletionCandidate(
            *static_cast<const T*>(this),
            threadOwnsDepotLock);
      } else {
        // No depot, so destroy this object directly.
        delete static_cast<const T*>(this);
      }
    }
  }
 
  mutable std::atomic<std::int32_t> _referenceCount{0};
  IDepotOwningAsset<T>* _pDepot{nullptr};
  bool _isInvalidated{false};
 
  // To allow the depot to modify _pDepot.
  template <typename TAssetType, typename TAssetKey, typename TContext>
  friend class CesiumAsync::SharedAssetDepot;
  friend T;
};
 
} // namespace CesiumUtility