Blackboard.h

#pragma once
 
#include <Core/CoreDLL.h>
#include <Foundation/Communication/Event.h>
#include <Foundation/Strings/HashedString.h>
#include <Foundation/Types/SharedPtr.h>
#include <Foundation/Types/Variant.h>
 
class plStreamReader;
class plStreamWriter;
 
struct PL_CORE_DLL plBlackboardEntryFlags
{
  using StorageType = plUInt16;
 
  enum Enum
  {
    None = 0,
    Save = PL_BIT(0),          
    OnChangeEvent = PL_BIT(1), 
 
    UserFlag0 = PL_BIT(7),
    UserFlag1 = PL_BIT(8),
    UserFlag2 = PL_BIT(9),
    UserFlag3 = PL_BIT(10),
    UserFlag4 = PL_BIT(11),
    UserFlag5 = PL_BIT(12),
    UserFlag6 = PL_BIT(13),
    UserFlag7 = PL_BIT(14),
 
    Invalid = PL_BIT(15),
 
    Default = None
  };
 
  struct Bits
  {
    StorageType Save : 1;
    StorageType OnChangeEvent : 1;
    StorageType Reserved : 5;
    StorageType UserFlag0 : 1;
    StorageType UserFlag1 : 1;
    StorageType UserFlag2 : 1;
    StorageType UserFlag3 : 1;
    StorageType UserFlag4 : 1;
    StorageType UserFlag5 : 1;
    StorageType UserFlag6 : 1;
    StorageType UserFlag7 : 1;
    StorageType Invalid : 1;
  };
};
 
PL_DECLARE_FLAGS_OPERATORS(plBlackboardEntryFlags);
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plBlackboardEntryFlags);
 
 
class PL_CORE_DLL plBlackboard : public plRefCounted
{
private:
  plBlackboard(bool bIsGlobal);
 
public:
  ~plBlackboard();
 
  bool IsGlobalBlackboard() const { return m_bIsGlobal; }
 
  static plSharedPtr<plBlackboard> Create(plAllocator* pAllocator = plFoundation::GetDefaultAllocator());
 
  static plSharedPtr<plBlackboard> GetOrCreateGlobal(const plHashedString& sBlackboardName, plAllocator* pAllocator = plFoundation::GetDefaultAllocator());
 
  static plSharedPtr<plBlackboard> FindGlobal(const plTempHashedString& sBlackboardName);
 
  void SetName(plStringView sName);
  const char* GetName() const { return m_sName; }
  const plHashedString& GetNameHashed() const { return m_sName; }
 
  struct Entry
  {
    plVariant m_Value;
    plBitflags<plBlackboardEntryFlags> m_Flags;
 
    plUInt32 m_uiChangeCounter = 0;
  };
 
  struct EntryEvent
  {
    plHashedString m_sName;
    plVariant m_OldValue;
    const Entry* m_pEntry;
  };
 
  void RemoveEntry(const plHashedString& sName);
 
  void RemoveAllEntries();
 
  bool HasEntry(const plTempHashedString& sName) const;
 
  void SetEntryValue(plStringView sName, const plVariant& value);
 
  void SetEntryValue(const plHashedString& sName, const plVariant& value);
 
  const Entry* GetEntry(const plTempHashedString& sName) const;
 
  plBitflags<plBlackboardEntryFlags> GetEntryFlags(const plTempHashedString& sName) const;
 
  plResult SetEntryFlags(const plTempHashedString& sName, plBitflags<plBlackboardEntryFlags> flags);
 
  plVariant GetEntryValue(const plTempHashedString& sName, const plVariant& fallback = plVariant()) const;
 
  plVariant IncrementEntryValue(const plTempHashedString& sName);
 
  plVariant DecrementEntryValue(const plTempHashedString& sName);
 
  const plHashTable<plHashedString, Entry>& GetAllEntries() const { return m_Entries; }
 
  const plEvent<EntryEvent>& OnEntryEvent() const { return m_EntryEvents; }
 
  plUInt32 GetBlackboardChangeCounter() const { return m_uiBlackboardChangeCounter; }
 
  plUInt32 GetBlackboardEntryChangeCounter() const { return m_uiBlackboardEntryChangeCounter; }
 
  plResult Serialize(plStreamWriter& inout_stream) const;
 
  plResult Deserialize(plStreamReader& inout_stream);
 
private:
  PL_ALLOW_PRIVATE_PROPERTIES(plBlackboard);
 
  static plBlackboard* Reflection_GetOrCreateGlobal(const plHashedString& sName);
  static plBlackboard* Reflection_FindGlobal(plTempHashedString sName);
  void Reflection_SetEntryValue(plStringView sName, const plVariant& value);
 
  void ImplSetEntryValue(const plHashedString& sName, Entry& entry, const plVariant& value);
 
  bool m_bIsGlobal = false;
  plHashedString m_sName;
  plEvent<EntryEvent> m_EntryEvents;
  plUInt32 m_uiBlackboardChangeCounter = 0;
  plUInt32 m_uiBlackboardEntryChangeCounter = 0;
  plHashTable<plHashedString, Entry> m_Entries;
 
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Core, Blackboard);
  static plMutex s_GlobalBlackboardsMutex;
  static plHashTable<plHashedString, plSharedPtr<plBlackboard>> s_GlobalBlackboards;
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plBlackboard);
 
 
struct PL_CORE_DLL plBlackboardCondition
{
  plHashedString m_sEntryName;
  double m_fComparisonValue = 0.0;
  plEnum<plComparisonOperator> m_Operator;
 
  bool IsConditionMet(const plBlackboard& blackboard) const;
 
  plResult Serialize(plStreamWriter& inout_stream) const;
  plResult Deserialize(plStreamReader& inout_stream);
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plBlackboardCondition);