ResourceHandle.h

#pragma once
 
#include <Core/CoreDLL.h>
#include <Core/ResourceManager/Implementation/Declarations.h>
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Strings/String.h>
 
#define PL_RESOURCEHANDLE_STACK_TRACES PL_OFF
 
class plResource;
 
template <typename T>
class plResourceLock;
 
// These out-of-line helper functions allow to forward declare resource handles without knowledge about the resource class.
PL_CORE_DLL void IncreaseResourceRefCount(plResource* pResource, const void* pOwner);
PL_CORE_DLL void DecreaseResourceRefCount(plResource* pResource, const void* pOwner);
 
#if PL_ENABLED(PL_RESOURCEHANDLE_STACK_TRACES)
PL_CORE_DLL void MigrateResourceRefCount(plResource* pResource, const void* pOldOwner, const void* pNewOwner);
#else
PL_ALWAYS_INLINE void MigrateResourceRefCount(plResource* pResource, const void* pOldOwner, const void* pNewOwner)
{
}
#endif
 
class PL_CORE_DLL plTypelessResourceHandle
{
public:
  PL_ALWAYS_INLINE plTypelessResourceHandle() = default;
 
  plTypelessResourceHandle(plResource* pResource);
 
  PL_ALWAYS_INLINE plTypelessResourceHandle(const plTypelessResourceHandle& rhs)
  {
    m_pResource = rhs.m_pResource;
 
    if (m_pResource)
    {
      IncreaseResourceRefCount(m_pResource, this);
    }
  }
 
  PL_ALWAYS_INLINE plTypelessResourceHandle(plTypelessResourceHandle&& rhs)
  {
    m_pResource = rhs.m_pResource;
    rhs.m_pResource = nullptr;
 
    if (m_pResource)
    {
      MigrateResourceRefCount(m_pResource, &rhs, this);
    }
  }
 
  PL_ALWAYS_INLINE ~plTypelessResourceHandle() { Invalidate(); }
 
  PL_ALWAYS_INLINE bool IsValid() const { return m_pResource != nullptr; }
 
  void Invalidate();
 
  plUInt64 GetResourceIDHash() const;
 
  const plString& GetResourceID() const;
 
  void operator=(const plTypelessResourceHandle& rhs);
 
  void operator=(plTypelessResourceHandle&& rhs);
 
  PL_ALWAYS_INLINE bool operator==(const plTypelessResourceHandle& rhs) const { return m_pResource == rhs.m_pResource; }
 
  PL_ALWAYS_INLINE bool operator!=(const plTypelessResourceHandle& rhs) const { return m_pResource != rhs.m_pResource; }
 
  PL_ALWAYS_INLINE bool operator<(const plTypelessResourceHandle& rhs) const { return m_pResource < rhs.m_pResource; }
 
  PL_ALWAYS_INLINE bool operator==(const plResource* rhs) const { return m_pResource == rhs; }
 
  PL_ALWAYS_INLINE bool operator!=(const plResource* rhs) const { return m_pResource != rhs; }
 
  const plRTTI* GetResourceType() const;
 
protected:
  plResource* m_pResource = nullptr;
 
private:
  // you must go through the resource manager to get access to the resource pointer
  friend class plResourceManager;
  friend class plResourceHandleWriteContext;
  friend class plResourceHandleReadContext;
  friend class plResourceHandleStreamOperations;
};
 
template <>
struct plHashHelper<plTypelessResourceHandle>
{
  PL_ALWAYS_INLINE static plUInt32 Hash(const plTypelessResourceHandle& value) { return plHashingUtils::StringHashTo32(value.GetResourceIDHash()); }
 
  PL_ALWAYS_INLINE static bool Equal(const plTypelessResourceHandle& a, const plTypelessResourceHandle& b) { return a == b; }
};
 
template <typename RESOURCE_TYPE>
class plTypedResourceHandle
{
public:
  using ResourceType = RESOURCE_TYPE;
 
  plTypedResourceHandle() = default;
 
  explicit plTypedResourceHandle(ResourceType* pResource)
    : m_hTypeless(pResource)
  {
  }
 
  plTypedResourceHandle(const plTypedResourceHandle<ResourceType>& rhs)
    : m_hTypeless(rhs.m_hTypeless)
  {
  }
 
  plTypedResourceHandle(plTypedResourceHandle<ResourceType>&& rhs)
    : m_hTypeless(std::move(rhs.m_hTypeless))
  {
  }
 
  template <typename BaseOrDerivedType>
  plTypedResourceHandle(const plTypedResourceHandle<BaseOrDerivedType>& rhs)
    : m_hTypeless(rhs.m_hTypeless)
  {
    static_assert(std::is_base_of<ResourceType, BaseOrDerivedType>::value || std::is_base_of<BaseOrDerivedType, ResourceType>::value, "Only related types can be assigned to handles of this type");
 
#if PL_ENABLED(PL_COMPILE_FOR_DEBUG)
    if (std::is_base_of<BaseOrDerivedType, ResourceType>::value)
    {
      PL_ASSERT_DEBUG(rhs.IsValid(), "Cannot cast invalid base handle to derived type!");
      plResourceLock<BaseOrDerivedType> lock(rhs, plResourceAcquireMode::PointerOnly);
      PL_ASSERT_DEBUG(plDynamicCast<const ResourceType*>(lock.GetPointer()) != nullptr, "Types are not related!");
    }
#endif
  }
 
  void operator=(const plTypedResourceHandle<ResourceType>& rhs) { m_hTypeless = rhs.m_hTypeless; }
 
  void operator=(plTypedResourceHandle<ResourceType>&& rhs) { m_hTypeless = std::move(rhs.m_hTypeless); }
 
  PL_ALWAYS_INLINE bool operator==(const plTypedResourceHandle<ResourceType>& rhs) const { return m_hTypeless == rhs.m_hTypeless; }
 
  PL_ALWAYS_INLINE bool operator!=(const plTypedResourceHandle<ResourceType>& rhs) const { return m_hTypeless != rhs.m_hTypeless; }
 
  PL_ALWAYS_INLINE bool operator<(const plTypedResourceHandle<ResourceType>& rhs) const { return m_hTypeless < rhs.m_hTypeless; }
 
  PL_ALWAYS_INLINE bool operator==(const plResource* rhs) const { return m_hTypeless == rhs; }
 
  PL_ALWAYS_INLINE bool operator!=(const plResource* rhs) const { return m_hTypeless != rhs; }
 
 
  PL_ALWAYS_INLINE operator const plTypelessResourceHandle() const { return m_hTypeless; }
 
  PL_ALWAYS_INLINE operator plTypelessResourceHandle() { return m_hTypeless; }
 
  PL_ALWAYS_INLINE bool IsValid() const { return m_hTypeless.IsValid(); }
 
  PL_ALWAYS_INLINE explicit operator bool() const { return m_hTypeless.IsValid(); }
 
  PL_ALWAYS_INLINE void Invalidate() { m_hTypeless.Invalidate(); }
 
  PL_ALWAYS_INLINE plUInt64 GetResourceIDHash() const { return m_hTypeless.GetResourceIDHash(); }
 
  PL_ALWAYS_INLINE const plString& GetResourceID() const { return m_hTypeless.GetResourceID(); }
 
  void AssignFromTypelessHandle(const plTypelessResourceHandle& hHandle)
  {
    if (!hHandle.IsValid())
      return;
 
    PL_ASSERT_DEV(hHandle.GetResourceType()->IsDerivedFrom<RESOURCE_TYPE>(), "Type '{}' does not match resource type '{}' in typeless handle.", plGetStaticRTTI<RESOURCE_TYPE>()->GetTypeName(), hHandle.GetResourceType()->GetTypeName());
 
    m_hTypeless = hHandle;
  }
 
private:
  template <typename T>
  friend class plTypedResourceHandle;
 
  // you must go through the resource manager to get access to the resource pointer
  friend class plResourceManager;
  friend class plResourceHandleWriteContext;
  friend class plResourceHandleReadContext;
  friend class plResourceHandleStreamOperations;
 
  plTypelessResourceHandle m_hTypeless;
};
 
template <typename T>
struct plHashHelper<plTypedResourceHandle<T>>
{
  PL_ALWAYS_INLINE static plUInt32 Hash(const plTypedResourceHandle<T>& value) { return plHashingUtils::StringHashTo32(value.GetResourceIDHash()); }
 
  PL_ALWAYS_INLINE static bool Equal(const plTypedResourceHandle<T>& a, const plTypedResourceHandle<T>& b) { return a == b; }
};
 
// Stream operations
class plResource;
 
class PL_CORE_DLL plResourceHandleStreamOperations
{
public:
  template <typename ResourceType>
  static void WriteHandle(plStreamWriter& inout_stream, const plTypedResourceHandle<ResourceType>& hResource)
  {
    WriteHandle(inout_stream, hResource.m_hTypeless.m_pResource);
  }
 
  template <typename ResourceType>
  static void ReadHandle(plStreamReader& inout_stream, plTypedResourceHandle<ResourceType>& ref_hResourceHandle)
  {
    ReadHandle(inout_stream, ref_hResourceHandle.m_hTypeless);
  }
 
private:
  static void WriteHandle(plStreamWriter& Stream, const plResource* pResource);
  static void ReadHandle(plStreamReader& Stream, plTypelessResourceHandle& ResourceHandle);
};
 
template <typename ResourceType>
void operator<<(plStreamWriter& inout_stream, const plTypedResourceHandle<ResourceType>& hValue)
{
  plResourceHandleStreamOperations::WriteHandle(inout_stream, hValue);
}
 
template <typename ResourceType>
void operator>>(plStreamReader& inout_stream, plTypedResourceHandle<ResourceType>& ref_hValue)
{
  plResourceHandleStreamOperations::ReadHandle(inout_stream, ref_hValue);
}