GraphVersioning.h

#pragma once
 
 
#include <Foundation/Algorithm/HashingUtils.h>
#include <Foundation/Basics.h>
#include <Foundation/Configuration/Singleton.h>
#include <Foundation/Configuration/Startup.h>
#include <Foundation/Containers/HashTable.h>
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Serialization/GraphPatch.h>
#include <Foundation/Strings/HashedString.h>
 
class plRTTI;
class plAbstractObjectNode;
class plAbstractObjectGraph;
class plGraphPatch;
class plGraphPatchContext;
class plGraphVersioning;
 
struct plVersionKey
{
  plVersionKey() = default;
  plVersionKey(plStringView sType, plUInt32 uiTypeVersion)
  {
    m_sType.Assign(sType);
    m_uiTypeVersion = uiTypeVersion;
  }
  PL_DECLARE_POD_TYPE();
  plHashedString m_sType;
  plUInt32 m_uiTypeVersion;
};
 
struct plGraphVersioningHash
{
  PL_FORCE_INLINE static plUInt32 Hash(const plVersionKey& a)
  {
    auto typeNameHash = a.m_sType.GetHash();
    plUInt32 uiHash = plHashingUtils::xxHash32(&typeNameHash, sizeof(typeNameHash));
    uiHash = plHashingUtils::xxHash32(&a.m_uiTypeVersion, sizeof(a.m_uiTypeVersion), uiHash);
    return uiHash;
  }
 
  PL_ALWAYS_INLINE static bool Equal(const plVersionKey& a, const plVersionKey& b)
  {
    return a.m_sType == b.m_sType && a.m_uiTypeVersion == b.m_uiTypeVersion;
  }
};
 
struct PL_FOUNDATION_DLL plTypeVersionInfo
{
  const char* GetTypeName() const;
  void SetTypeName(const char* szName);
  const char* GetParentTypeName() const;
  void SetParentTypeName(const char* szName);
 
  plHashedString m_sTypeName;
  plHashedString m_sParentTypeName;
  plUInt32 m_uiTypeVersion;
};
PL_DECLARE_REFLECTABLE_TYPE(PL_FOUNDATION_DLL, plTypeVersionInfo);
 
class PL_FOUNDATION_DLL plGraphPatchContext
{
public:
  void PatchBaseClass(const char* szType, plUInt32 uiTypeVersion, bool bForcePatch = false); // [tested]
 
  void RenameClass(const char* szTypeName); // [tested]
 
  void RenameClass(const char* szTypeName, plUInt32 uiVersion);
 
  void ChangeBaseClass(plArrayPtr<plVersionKey> baseClasses); // [tested]
 
private:
  friend class plGraphVersioning;
  plGraphPatchContext(plGraphVersioning* pParent, plAbstractObjectGraph* pGraph, plAbstractObjectGraph* pTypesGraph);
  void Patch(plAbstractObjectNode* pNode);
  void Patch(plUInt32 uiBaseClassIndex, plUInt32 uiTypeVersion, bool bForcePatch);
  void UpdateBaseClasses();
 
private:
  plGraphVersioning* m_pParent = nullptr;
  plAbstractObjectGraph* m_pGraph = nullptr;
  plAbstractObjectNode* m_pNode = nullptr;
  plDynamicArray<plVersionKey> m_BaseClasses;
  plUInt32 m_uiBaseClassIndex = 0;
  mutable plHashTable<plHashedString, plTypeVersionInfo> m_TypeToInfo;
};
 
class PL_FOUNDATION_DLL plGraphVersioning
{
  PL_DECLARE_SINGLETON(plGraphVersioning);
 
public:
  plGraphVersioning();
  ~plGraphVersioning();
 
  void PatchGraph(plAbstractObjectGraph* pGraph, plAbstractObjectGraph* pTypesGraph = nullptr);
 
private:
  friend class plGraphPatchContext;
 
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Foundation, GraphVersioning);
 
  void PluginEventHandler(const plPluginEvent& EventData);
  void UpdatePatches();
  plUInt32 GetMaxPatchVersion(const plHashedString& sType) const;
 
  plHashTable<plHashedString, plUInt32> m_MaxPatchVersion; 
  plDynamicArray<const plGraphPatch*> m_GraphPatches;
  plHashTable<plVersionKey, const plGraphPatch*, plGraphVersioningHash> m_NodePatches;
};