Changeset 6017 for branches/newapi

Timestamp:

01/11/08 05:31:23 (11 months ago)

Author:

erijo

Message:

Implemented methods in EventManager? for (un)register event queues and for sending events.

Location:

branches/newapi/licq/src/event

Files:

• eventmanager.h (modified) (1 diff)
• eventmanagerimpl.cpp (modified) (2 diffs)
• eventmanagerimpl.h (modified) (3 diffs)

branches/newapi/licq/src/event/eventmanager.h

@@ -30 +30 @@
 {
 public:
-  virtual void registerQueue(const std::string& event,
+  virtual void registerQueue(const std::string& name,
                              Licq::EventQueue* queue,
                              int priority) = 0;
 
-  virtual void unregisterQueue(const std::string& event,
+  virtual void unregisterQueue(const std::string& name,
                                Licq::EventQueue* queue) = 0;
 
   virtual void unregisterQueue(Licq::EventQueue* queue) = 0;
 
-  virtual void sendEvent(boost::shared_ptr<Licq::Event>& event) = 0;
+  virtual void sendEvent(const std::string& name,
+                         boost::shared_ptr<Licq::Event> event) = 0;
 
 protected:

branches/newapi/licq/src/event/eventmanagerimpl.cpp

@@ -19 +19 @@
 
 #include "event/eventmanagerimpl.h"
+#include "licq/thread/readlocker.h"
+#include "licq/thread/writelocker.h"
+#include "globals.h"
+#include "util/tr.h"
 
-void LicqDaemon::EventManagerImpl::registerQueue(const std::string& event,
+void LicqDaemon::EventManagerImpl::registerQueue(const std::string& name,
                                                  Licq::EventQueue* queue,
                                                  int priority)
 {
+  Licq::WriteLocker locker(&myEventPipesMutex);
+
+  EventPipes::iterator pipe = myEventPipes.find(name);
+  if (pipe == myEventPipes.end())
+    pipe = myEventPipes.insert(std::make_pair(name, new EventPipe(name))).first;
+
+  pipe->second->addQueue(queue, priority);
 }
 
-void LicqDaemon::EventManagerImpl::unregisterQueue(const std::string& event,
+void LicqDaemon::EventManagerImpl::unregisterQueue(const std::string& name,
                                                    Licq::EventQueue* queue)
 {
+  Licq::WriteLocker locker(&myEventPipesMutex);
+
+  EventPipes::iterator pipe = myEventPipes.find(name);
+  if (pipe == myEventPipes.end())
+  {
+    myLog.warning(tr("No queues registered for %1%") % name);
+    return;
+  }
+
+  removeQueue(pipe, queue);
 }
 
 void LicqDaemon::EventManagerImpl::unregisterQueue(Licq::EventQueue* queue)
 {
+  Licq::WriteLocker locker(&myEventPipesMutex);
+
+  for (EventPipes::iterator pipe = myEventPipes.begin();
+       pipe != myEventPipes.end();)
+  {
+    removeQueue(pipe++, queue);
+  }
 }
 
-void LicqDaemon::EventManagerImpl::sendEvent(boost::shared_ptr<Licq::Event>& event)
+void LicqDaemon::EventManagerImpl::sendEvent(const std::string& name,
+                                             boost::shared_ptr<Licq::Event> event)
 {
+  Licq::ReadLocker locker(&myEventPipesMutex);
+
+  EventPipes::iterator pipe = myEventPipes.find(name);
+  if (pipe == myEventPipes.end())
+  {
+    myLog.warning(tr("No queues registered for %1%") % name);
+    return;
+  }
+
+  pipe->second->processEvent(event);
 }
 
 LicqDaemon::EventManagerImpl::EventManagerImpl()
-  : myEventQueuesMutex("EventManager")
+  : myLog(Globals::getDaemonLog()),
+    myEventPipesMutex("EventManager")
 {
 }
@@ -46 +86 @@
 LicqDaemon::EventManagerImpl::~EventManagerImpl()
 {
+  Licq::WriteLocker locker(&myEventPipesMutex);
+  while (!myEventPipes.empty())
+    deletePipe(myEventPipes.begin());
 }
+
+void LicqDaemon::EventManagerImpl::removeQueue(EventPipes::iterator pipe,
+                                               Licq::EventQueue* queue)
+{
+  pipe->second->removeQueue(queue);
+  if (pipe->second->empty())
+    deletePipe(pipe);
+}
+
+void LicqDaemon::EventManagerImpl::deletePipe(EventPipes::iterator pipe)
+{
+  delete pipe->second;
+  myEventPipes.erase(pipe);
+}

branches/newapi/licq/src/event/eventmanagerimpl.h

@@ -22 +22 @@
 
 #include "event/eventmanager.h"
+#include "event/eventpipe.h"
 #include "event/eventqueue.h"
 #include "licq/event/event.h"
+#include "licq/log.h"
 #include "licq/thread/readwritemutex.h"
 
@@ -35 +37 @@
 {
 public:
-  void registerQueue(const std::string& event, Licq::EventQueue* queue, int priority);
-  void unregisterQueue(const std::string& event, Licq::EventQueue* queue);
+  void registerQueue(const std::string& name,
+                     Licq::EventQueue* queue,
+                     int priority);
+
+  void unregisterQueue(const std::string& name,
+                       Licq::EventQueue* queue);
+
   void unregisterQueue(Licq::EventQueue* queue);
 
-  void sendEvent(boost::shared_ptr<Licq::Event>& event);
+  void sendEvent(const std::string& name,
+                 boost::shared_ptr<Licq::Event> event);
 
 private:
@@ -47 +55 @@
   ~EventManagerImpl();
 
-  struct EventQueuePriority
-  {
-    EventQueue* queue;
-    int priority;
-  };
+  Licq::Log& myLog;
 
-  typedef std::vector<EventQueuePriority> EventQueues;
-  std::map<std::string, EventQueues> myEventQueues;
-  Licq::ReadWriteMutex myEventQueuesMutex;
+  typedef std::map<std::string, EventPipe*> EventPipes;
+  EventPipes myEventPipes;
+  Licq::ReadWriteMutex myEventPipesMutex;
+
+  void removeQueue(EventPipes::iterator pipe, Licq::EventQueue* queue);
+  void deletePipe(EventPipes::iterator pipe);
 };