tb_resource_handle.hpp

 
#ifndef TurtleBrains_ResourceHandle_hpp
#define TurtleBrains_ResourceHandle_hpp
 
#include <turtle_brains/core/tb_types.hpp>
 
#include <functional> //for std::hash()
 
namespace TurtleBrains::Core
{
 
    template<typename Type> class ResourceHandle
    {
    public:
        ResourceHandle(void);
 
        ~ResourceHandle(void);
 
        bool IsValid(void) const;
 
        operator bool() const;
 
        bool operator==(const ResourceHandle& other) const;
 
        bool operator!=(const ResourceHandle& other) const;
 
        bool operator<(const ResourceHandle& other) const
        {
            return mValue < other.mValue;
        }
 
        //inline size_t GetHash(void) const { return std::hash<tbCore::uint32>(mValue); }
        inline size_t GetHash(void) const { return mValue; }
 
    //Was unable to make this private because the template friend class was not working. I believe it requires
    //The friend class to have been declared already, which would create circular dependencies.
    //private:
        //template<typename ResourceType, typename HandleType> friend class TurtleBrains::Core::ResourceCache;
 
        ResourceHandle(const tbCore::uint32 value);
 
        //operator size_t() const;
 
        tbCore::uint32 mValue;
    };
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
//--------------------------------------------------------------------------------------------------------------------//
 
// 2025-11-09: This fixes an issue where std::unordered_map<ResourceHandle<Type>> would complain about the std::hash not
//   being defined/usable. It does have to be in global space to work.
template<typename Type> struct std::hash<TurtleBrains::Core::ResourceHandle<Type>>
{
    std::size_t operator()(const TurtleBrains::Core::ResourceHandle<Type>& handle) const
    {
        return handle.GetHash();
    }
};
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename Type> TurtleBrains::Core::ResourceHandle<Type>::ResourceHandle(void) :
    mValue(static_cast<tbCore::uint32>(~0))
{
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename Type> TurtleBrains::Core::ResourceHandle<Type>::~ResourceHandle(void)
{
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename Type> bool TurtleBrains::Core::ResourceHandle<Type>::IsValid(void) const
{
    return mValue != static_cast<tbCore::uint32>(~0);
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename Type> TurtleBrains::Core::ResourceHandle<Type>::operator bool() const
{
    return IsValid();
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename Type> bool TurtleBrains::Core::ResourceHandle<Type>::operator==(const ResourceHandle& other) const
{
    return mValue == other.mValue;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename Type> bool TurtleBrains::Core::ResourceHandle<Type>::operator!=(const ResourceHandle& other) const
{
    return mValue != other.mValue;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename Type> TurtleBrains::Core::ResourceHandle<Type>::ResourceHandle(const tbCore::uint32 value) :
    mValue(value)
{
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
//template<typename Type> TurtleBrains::Core::ResourceHandle<Type>::operator size_t() const
//{
//  return static_cast<size_t>(mValue);
//}
 
//--------------------------------------------------------------------------------------------------------------------//
 
#endif /* TurtleBrains_ResourceHandle_hpp */