MessageQueue.h

 
#pragma once
 
#include <Foundation/Communication/Message.h>
#include <Foundation/Containers/Deque.h>
#include <Foundation/Threading/Lock.h>
#include <Foundation/Threading/Mutex.h>
 
template <typename MetaDataType>
class plMessageQueueBase
{
public:
  struct Entry
  {
    PL_DECLARE_POD_TYPE();
 
    plMessage* m_pMessage;
    MetaDataType m_MetaData;
    mutable plUInt64 m_uiMessageHash = 0;
  };
 
protected:
  plMessageQueueBase(plAllocator* pAllocator); // [tested]
 
  plMessageQueueBase(const plMessageQueueBase& rhs, plAllocator* pAllocator);
 
  ~plMessageQueueBase(); // [tested]
 
  void operator=(const plMessageQueueBase& rhs);
 
public:
  Entry& operator[](plUInt32 uiIndex); // [tested]
 
  const Entry& operator[](plUInt32 uiIndex) const; // [tested]
 
  plUInt32 GetCount() const;
 
  bool IsEmpty() const;
 
  void Clear();
 
  void Reserve(plUInt32 uiCount);
 
  void Compact();
 
  void Enqueue(plMessage* pMessage, const MetaDataType& metaData); // [tested]
 
  bool TryDequeue(plMessage*& out_pMessage, MetaDataType& out_metaData); // [tested]
 
  bool TryPeek(plMessage*& out_pMessage, MetaDataType& out_metaData); // [tested]
 
  Entry& Peek();
 
  void Dequeue();
 
  template <typename Comparer>
  void Sort(const Comparer& comparer); // [tested]
 
  void Lock(); // [tested]
 
  void Unlock(); // [tested]
 
private:
  plDeque<Entry, plNullAllocatorWrapper> m_Queue;
  plMutex m_Mutex;
};
 
template <typename MetaDataType, typename AllocatorWrapper = plDefaultAllocatorWrapper>
class plMessageQueue : public plMessageQueueBase<MetaDataType>
{
public:
  plMessageQueue();
  plMessageQueue(plAllocator* pAllocator);
 
  plMessageQueue(const plMessageQueue<MetaDataType, AllocatorWrapper>& rhs);
  plMessageQueue(const plMessageQueueBase<MetaDataType>& rhs);
 
  void operator=(const plMessageQueue<MetaDataType, AllocatorWrapper>& rhs);
  void operator=(const plMessageQueueBase<MetaDataType>& rhs);
};
 
#include <Foundation/Communication/Implementation/MessageQueue_inl.h>