Event.h

#pragma once
 
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Threading/Lock.h>
#include <Foundation/Threading/Mutex.h>
#include <Foundation/Types/Delegate.h>
 
using plEventSubscriptionID = plUInt32;
 
enum class plEventType
{
  Default,        
  CopyOnBroadcast 
};
 
template <typename EventData, typename MutexType, plEventType EventType>
class plEventBase
{
protected:
  plEventBase(plAllocator* pAllocator);
  ~plEventBase();
 
public:
  using Handler = plDelegate<void(EventData)>;
 
  class Unsubscriber
  {
    PL_DISALLOW_COPY_AND_ASSIGN(Unsubscriber);
 
  public:
    Unsubscriber() = default;
    Unsubscriber(Unsubscriber&& other)
    {
      m_pEvent = other.m_pEvent;
      m_SubscriptionID = other.m_SubscriptionID;
      other.Clear();
    }
    ~Unsubscriber() { Unsubscribe(); }
 
    void operator=(Unsubscriber&& other)
    {
      Unsubscribe();
 
      m_pEvent = other.m_pEvent;
      m_SubscriptionID = other.m_SubscriptionID;
      other.Clear();
    }
 
    void Unsubscribe()
    {
      if (m_SubscriptionID == 0)
        return;
 
      m_pEvent->RemoveEventHandler(m_SubscriptionID);
      Clear();
    }
 
    bool IsSubscribed() const { return m_SubscriptionID != 0; }
 
    void Clear()
    {
      m_pEvent = nullptr;
      m_SubscriptionID = 0;
    }
 
  private:
    friend class plEventBase<EventData, MutexType, EventType>;
 
    const plEventBase<EventData, MutexType, EventType>* m_pEvent = nullptr;
    plEventSubscriptionID m_SubscriptionID = 0;
  };
 
  enum
  {
    RecursionDepthSupported = (EventType == plEventType::Default || plConversionTest<MutexType, plNoMutex>::sameType == 1) ? 1 : 0,
 
    MaxRecursionDepthDefault = RecursionDepthSupported ? 0 : 255
  };
 
  void Broadcast(EventData pEventData, plUInt8 uiMaxRecursionDepth = MaxRecursionDepthDefault); // [tested]
 
  plEventSubscriptionID AddEventHandler(Handler handler) const; // [tested]
 
  void AddEventHandler(Handler handler, Unsubscriber& inout_unsubscriber) const; // [tested]
 
  void RemoveEventHandler(const Handler& handler) const; // [tested]
 
  void RemoveEventHandler(plEventSubscriptionID& inout_id) const;
 
  bool HasEventHandler(const Handler& handler) const;
 
  void Clear();
 
  bool IsEmpty() const;
 
  // it would be a problem if the plEvent moves in memory, for instance the Unsubscriber's would point to invalid memory
  PL_DISALLOW_COPY_AND_ASSIGN(plEventBase);
 
private:
  // Used to detect recursive broadcasts and then throw asserts at you.
  plUInt8 m_uiRecursionDepth = 0;
  mutable plEventSubscriptionID m_NextSubscriptionID = 0;
 
  mutable MutexType m_Mutex;
 
#if PL_ENABLED(PL_COMPILE_FOR_DEVELOPMENT)
  const void* m_pSelf = nullptr;
#endif
 
  struct HandlerData
  {
    Handler m_Handler;
    plEventSubscriptionID m_SubscriptionID;
  };
 
  mutable plDynamicArray<HandlerData> m_EventHandlers;
};
 
struct plNoEventData
{
};
 
template <typename EventData, typename MutexType = plNoMutex, typename AllocatorWrapper = plDefaultAllocatorWrapper, plEventType EventType = plEventType::Default>
class plEvent : public plEventBase<EventData, MutexType, EventType>
{
public:
  plEvent();
  plEvent(plAllocator* pAllocator);
};
 
template <typename EventData, typename MutexType = plNoMutex, typename AllocatorWrapper = plDefaultAllocatorWrapper>
using plCopyOnBroadcastEvent = plEvent<EventData, MutexType, AllocatorWrapper, plEventType::CopyOnBroadcast>;
 
#include <Foundation/Communication/Implementation/Event_inl.h>