TWeakHandle.h

Go to the documentation of this file.

#pragma once
 
#include "EditorCore/Storage/fwd.h"
 
#include <Common/Utility/string_utils.h>
#include <Utility/traits.h>
#include <Utility/utility.h>
#include <Math/hash.h>
 
#include <cstddef>
#include <limits>
#include <string>
#include <functional>
 
namespace ph::editor
{
 
template<typename Item, typename Index = std::size_t, typename Generation = Index>
class TWeakHandle final
{
public:
    using WeakHandleTag = void;
    using ItemType = Item;
    using IndexType = Index;
    using GenerationType = Generation;
 
    inline static constexpr auto INVALID_INDEX = std::numeric_limits<Index>::max();
    inline static constexpr auto INVALID_GENERATION = 0;
 
    PH_DEFINE_INLINE_RULE_OF_5_MEMBERS(TWeakHandle);
 
    inline TWeakHandle(Index itemIdx, Generation itemGeneration)
        : m_itemIdx(itemIdx)
        , m_itemGeneration(itemGeneration)
    {}
 
    template<CDerived<Item> DerivedItem>
    inline TWeakHandle(const TWeakHandle<DerivedItem, Index, Generation>& otherHandle)
        : TWeakHandle(otherHandle.getIndex(), otherHandle.getGeneration())
    {}
 
    inline Index getIndex() const
    {
        return m_itemIdx;
    }
 
    inline Generation getGeneration() const
    {
        return m_itemGeneration;
    }
 
    inline bool isEmpty() const
    {
        return m_itemIdx == INVALID_INDEX || m_itemGeneration == INVALID_GENERATION;
    }
 
    inline std::string toString() const
    {
        std::string indexStr = m_itemIdx != INVALID_INDEX
            ? std::to_string(m_itemIdx) : "invalid";
        std::string generationStr = m_itemGeneration != INVALID_GENERATION
            ? std::to_string(m_itemGeneration) : "invalid";
        return "[index=" + indexStr + ", generation=" + generationStr + "]";
    }
 
    inline operator bool () const
    {
        return !isEmpty();
    }
 
    inline bool operator == (const TWeakHandle& rhs) const = default;
 
    inline static constexpr Generation nextGeneration(const Generation currentGeneration)
    {
        Index nextGen = currentGeneration + 1;
        if(nextGen == INVALID_GENERATION)
        {
            ++nextGen;
        }
        return nextGen;
    }
 
private:
    Index m_itemIdx = INVALID_INDEX;
    Generation m_itemGeneration = INVALID_GENERATION;
};
 
}// end namespace ph::editor
 
template<typename Item, typename Index, typename Generation>
PH_DEFINE_INLINE_TO_STRING_FORMATTER_TEMPLATE(ph::editor::TWeakHandle<Item, Index, Generation>);
 
namespace std
{
 
template<ph::editor::CWeakHandle Handle>
struct hash<Handle>
{
    std::size_t operator () (const Handle& handle) const
    {
        return ph::math::murmur3_32(handle, 0);
    }
};
 
}// end namespace std