ResourceHandle.h

#pragma once
 
#include "../Base.h"
 
#include "Foundation/HashFunctions.h"
 
#include <functional>
 
namespace Cogs
{
  namespace Core
  {
    struct ResourceBase;
 
    struct COGSCORE_DLL_API ResourceHandleBase
    {
      ResourceHandleBase() = default;
 
      ResourceHandleBase(ResourceBase * resource)
      {
        reset(resource);
      }
 
      ResourceHandleBase(const ResourceHandleBase & other)
      {
        reset(other.resource);
      }
 
      ResourceHandleBase(ResourceHandleBase && other) noexcept : resource(other.resource)
      {
        other.resource = nullptr;
      }
 
      ~ResourceHandleBase();
      
      ResourceHandleBase & operator=(const ResourceHandleBase & other) { reset(other.resource); return *this; }
 
      bool operator==(const ResourceHandleBase & other) const { return this->resource == other.resource; }
 
      bool operator!=(const ResourceHandleBase & other) const { return !(*this == other); }
 
      operator bool() const { return this->resource != nullptr; }
 
 
      ResourceBase * operator->() { return this->resource; }
      const ResourceBase * operator->() const { return this->resource; }
 
      ResourceBase * get() { return this->resource; }
 
      const ResourceBase * get() const { return this->resource; }
 
      void reset(ResourceBase * otherResource);
 
      const static ResourceHandleBase NoHandle;
 
      ResourceId getId() const;
 
      size_t hash(size_t hashValue = Cogs::hash()) const {
        return Cogs::hash(reinterpret_cast<intptr_t>(resource), hashValue);
      }
 
    protected:
      void resetInternal(ResourceBase * otherResource);
 
      ResourceBase * resource = nullptr;
    };
 
    template<typename ResourceType>
    struct ResourceHandle_t : public ResourceHandleBase
    {
      ResourceHandle_t() = default;
 
      explicit ResourceHandle_t(ResourceBase * resource) : ResourceHandleBase(resource) {}
 
      ResourceHandle_t(const ResourceHandle_t & other) : ResourceHandleBase(other) {}
 
      ResourceHandle_t(ResourceHandle_t && other) noexcept : ResourceHandleBase(std::move(other)) {}
 
      ResourceHandle_t & operator=(const ResourceHandle_t & other) { ResourceHandleBase::operator=(other); return *this; }
 
      ResourceHandle_t(const ResourceHandleBase & other)
      {
        reset(const_cast<ResourceBase *>(other.get()));
      }
 
      ResourceType * resolve() const { return static_cast<ResourceType *>(resource); }
 
      ResourceType * operator->() const { return static_cast<ResourceType *>(resource); }
 
      const static ResourceHandle_t NoHandle;
 
    private:
      // Let hashing algorithm access our internal contents.
      friend struct std::hash<ResourceHandle_t<ResourceType>>;
    };
 
    template<typename T>
    const ResourceHandle_t<T> ResourceHandle_t<T>::NoHandle = ResourceHandle_t<T>(nullptr);
 
    template<typename T>
    inline bool HandleIsValid(const ResourceHandle_t<T> & handle)
    {
      return handle != ResourceHandle_t<T>::NoHandle;
    }
 
    inline bool HandleIsValid(const ResourceHandleBase & handle)
    {
      return handle != ResourceHandleBase::NoHandle;
    }
  }
}
 
 
namespace std
{
  template<>
  struct hash<Cogs::Core::ResourceHandleBase>
  {
    std::size_t operator()(const Cogs::Core::ResourceHandleBase & handle) const
    {
      return std::hash<const void *>()(handle.get());
    }
  };
}