Changeset 5619 for code/branches/libraries/src/orxonox/objects/quest/notifications/NotificationManager.cc

Timestamp:

Aug 11, 2009, 12:33:16 AM (15 years ago)

Author:

landauf

Message:

Moved Notification and NotificationManger from overlays to the quest objects (NotificationOverlay and NotificationQueue remain with the other overlays).

Added a new interface NotificationListener. The NotificationManager sends notifications to all listeners. NotificationQueue is such a listener (through inheritance). This removes another dependency between orxonox and overlays.

Location:

code/branches/libraries/src/orxonox/objects/quest/notifications

Files:

• . (added)
• NotificationManager.cc (moved) (moved from code/branches/libraries/src/orxonox/overlays/notifications/NotificationManager.cc) (5 diffs)

code/branches/libraries/src/orxonox/objects/quest/notifications/NotificationManager.cc

@@ -38 +38 @@
 #include "core/CoreIncludes.h"
 #include "Notification.h"
-#include "NotificationQueue.h"
+#include "interfaces/NotificationListener.h"
 
 namespace orxonox
@@ -69 +69 @@
     /**
     @brief
-        Registers a Notification within the NotificationManager and makes sure that the Notification is displayed in all the NotificationQueues associated with its sender.
+        Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationListeners associated with its sender.
     @param notification
         The Notification to be registered.
@@ -77 +77 @@
     bool NotificationManager::registerNotification(Notification* notification)
     {
-    
+
         if(notification == NULL) //!< A NULL-Notification cannot be registered.
             return false;
-        
+
         std::time_t time = std::time(0); //TDO: Doesn't this expire? //!< Get current time.
-        
+
         this->allNotificationsList_.insert(std::pair<std::time_t,Notification*>(time,notification));
-        
+
         if(notification->getSender() == NONE) //!< If the sender has no specific name, then the Notification is only added to the list of all Notifications.
             return true;
-        
+
         bool all = false;
-        if(notification->getSender() == ALL) //!< If all are the sender, then the Notifications is added to every NotificationQueue.
+        if(notification->getSender() == ALL) //!< If all are the sender, then the Notifications is added to every NotificationListener.
             all = true;
-        
-        //!< Insert the notification in all queues that have its sender as target.
-        for(std::map<NotificationQueue*,int>::iterator it = this->queueList_.begin(); it != this->queueList_.end(); it++) //!< Iterate through all queues.
+
+        //!< Insert the notification in all listeners that have its sender as target.
+        for(std::map<NotificationListener*,int>::iterator it = this->listenerList_.begin(); it != this->listenerList_.end(); it++) //!< Iterate through all listeners.
         {
             std::set<std::string> set = it->first->getTargetsSet();
             if(all || set.find(notification->getSender()) != set.end() || set.find(ALL) != set.end()) //TDO: Make sure this works.
             {
-                this->notificationLists_[it->second]->insert(std::pair<std::time_t,Notification*>(time,notification)); //!< Insert the Notification in the Notifications list of the current NotificationQueue.
-                it->first->update(notification, time); //!< Update the queue.
+                this->notificationLists_[it->second]->insert(std::pair<std::time_t,Notification*>(time,notification)); //!< Insert the Notification in the Notifications list of the current NotificationListener.
+                it->first->update(notification, time); //!< Update the listener.
             }
         }
-        
+
         COUT(3) << "Notification registered with the NotificationManager." << std::endl;
-        
+
         return true;
     }
-    
+
     /**
     @brief
-        Registers a NotificationQueue within the NotificationManager.
-    @param queue
-        The NotificationQueue to be registered.
+        Registers a NotificationListener within the NotificationManager.
+    @param listener
+        The NotificationListener to be registered.
     @return
         Returns true if successful.
     */
-    bool NotificationManager::registerQueue(NotificationQueue* queue)
+    bool NotificationManager::registerListener(NotificationListener* listener)
     {
         this->highestIndex_ += 1;
         int index = this->highestIndex_;
-        
-        this->queueList_[queue] = index; //!< Add the NotificationQueue to the list of queues.
-        
-        std::set<std::string> set = queue->getTargetsSet(); //TDO: Works this?
-        
-        //! If all senders are the target of the queue, then the list of notification for that specific queue is te same as the list of all Notifications.
+
+        this->listenerList_[listener] = index; //!< Add the NotificationListener to the list of listeners.
+
+        std::set<std::string> set = listener->getTargetsSet(); //TDO: Works this?
+
+        //! If all senders are the target of the listener, then the list of notification for that specific listener is te same as the list of all Notifications.
         if(set.find(ALL) != set.end())
         {
             this->notificationLists_[index] = &this->allNotificationsList_;
-            COUT(3) << "NotificationQueue registered with the NotificationManager." << std::endl;
+            COUT(3) << "NotificationListener registered with the NotificationManager." << std::endl;
             return true;
         }
-        
+
         this->notificationLists_[index] = new std::multimap<std::time_t,Notification*>;
         std::multimap<std::time_t,Notification*> map = *this->notificationLists_[index];
-        
-        //! Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
+
+        //! Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationListener.
         for(std::multimap<std::time_t,Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
         {
@@ -144 +144 @@
             }
         }
-        
-        queue->update(); //!< Update the queue.
 
-        COUT(3) << "NotificationQueue registered with the NotificationManager." << std::endl;
-        
+        listener->update(); //!< Update the listener.
+
+        COUT(3) << "NotificationListener registered with the NotificationManager." << std::endl;
+
         return true;
     }
-    
+
     /**
     @brief
-        Fetches the Notifications for a specific NotificationQueue in a specified timeframe.
-    @param queue
-        The NotificationQueue the Notifications are fetched for.
+        Fetches the Notifications for a specific NotificationListener in a specified timeframe.
+    @param listener
+        The NotificationListener the Notifications are fetched for.
     @param map
         A multimap, in which the notifications are stored.
@@ -166 +166 @@
         Returns true if successful.
     */
-    bool NotificationManager::getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
+    bool NotificationManager::getNotifications(NotificationListener* listener, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
     {
-        if(queue == NULL || map == NULL)
+        if(listener == NULL || map == NULL)
             return false;
 
-        std::multimap<std::time_t,Notification*>* notifications = this->notificationLists_[this->queueList_[queue]]; //!< The Notifications for the input NotificationQueue.
-        
+        std::multimap<std::time_t,Notification*>* notifications = this->notificationLists_[this->listenerList_[listener]]; //!< The Notifications for the input NotificationListener.
+
         if(notifications == NULL) //!< Returns NULL, if there are no Notifications.
             return true;
-    
+
         std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest;
         itLowest = notifications->lower_bound(timeFrameStart);
         itHighest = notifications->upper_bound(timeFrameStart);
-        
+
         for(it = itLowest; it != itHighest; it++) //!< Iterate through the Notifications from the start of the time Frame to the end of it.
         {
             map->insert(std::pair<std::time_t,Notification*>(it->first,it->second)); //!< Add the found Notifications to the map.
         }
-        
+
         return true;
     }