tb_resource_handle.hpp

#ifndef _TurtleBraines_ResourceHandle_hpp
#define _TurtleBraines_ResourceHandle_hpp

#include <turtle_brains/core/tb_types.hpp>

namespace TurtleBrains
{
    namespace 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;
            }

        //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 Core */
}; /* namespace TurtleBrains */

namespace tbCore = TurtleBrains::Core;

//-------------------------------------------------------------------------------------------------------------------//
//-------------------------------------------------------------------------------------------------------------------//
//-------------------------------------------------------------------------------------------------------------------//

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 /* _TurtleBraines_ResourceHandle_hpp */