MessageHub.h

#pragma once
 
#include "Message.h"
#include "../Platform/Threads.h"
 
#include <deque>
#include <vector>
 
namespace Cogs {
  namespace Network {
 
    // Known hub IDs...
    constexpr uint32_t    cApplicationHubID = 0x7FFF0000;
    constexpr uint32_t    cFirstWindowHubID = 0x7FFF1000;
 
    class COGSFOUNDATION_API MessageHub {
    public:
      using   MessageQueue  = std::deque< Message::Ptr >;
      using   HubList       = std::vector< MessageHub* >;
 
      static  constexpr size_t  noLimit = 10000000;
 
                            MessageHub(uint32_t ident = 0);
      virtual               ~MessageHub();
 
              bool          addListener(MessageHub* hub, bool bidirectional = false);
              bool          addListener(uint32_t hubid, bool bidirectional = false);
              bool          listenTo(MessageHub* hub, bool bidirectional = false);
              bool          listenTo(uint32_t hubid, bool bidirectional = false);
              bool          removeListener(MessageHub* hub);
              bool          removeListener(uint32_t hubid);
              void          removeAllListeners();
 
              void          disconnectFromSender(uint32_t hubid);
              void          disconnectFromAllSenders();
 
      virtual void          broadcastMessage(const Message::Ptr& message);    
      virtual void          sendMessage(const Message::Ptr& message);         
      virtual void          queueMessage(const Message::Ptr& message);        
      virtual bool          processMessages(size_t limit = noLimit);          
      virtual bool          isSendOnly() const              { return false; }
 
              uint32_t      getID() const                   { return id; }
              size_t        getNoOfQueuedMessages();
              void          flushQueuedMessages();
 
    protected:
              Message::Ptr  getNextMessage();
 
    private:
              MessageQueue  messages;           
              Mutex         messagesMutex;      
 
              HubList       listeners;          
              HubList       senders;            
              Mutex         hubsMutex;          
              uint32_t      id;                 
 
      virtual void          processMessage(Message& /*message*/)  {}
 
              void          addSender(MessageHub* sender);
              void          removeSender(const MessageHub* sender);
    };
 
    class COGSFOUNDATION_API SendOnlyMessageHub : public MessageHub {
    public:
                            SendOnlyMessageHub(uint32_t ident = 0) : MessageHub(ident)  {}
      virtual bool          isSendOnly() const override                                 { return true; }
 
    private:
      virtual void          queueMessage(const Message::Ptr& /*message*/) override      {}
    };
  }
}