Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/overlays/notifications/NotificationManager.cc @ 3078

Last change on this file since 3078 was 2911, checked in by landauf, 16 years ago

Merged r1-2096 of questsystem5 back to trunk

I hope there weren't more "hidden merge changes" in r2909 than the one in OverlayGroup (removeElement) (and related to this the adjustments in NotificationQueue).

The corresponding media commit seems not yet to be done, but it doesn't break the build.

  • Property svn:eol-style set to native
File size: 7.6 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Damian 'Mozork' Frick
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @file NotificationManager.cc
31    @brief Implementation of the NotificationManager class.
32*/
33
34#include "OrxonoxStableHeaders.h"
35#include "NotificationManager.h"
36
37#include "core/CoreIncludes.h"
38
39#include <set>
40
41#include "Notification.h"
42#include "NotificationQueue.h"
43
44namespace orxonox
45{
46
47    const std::string NotificationManager::ALL = "all";
48    const std::string NotificationManager::NONE = "none";
49
50    NotificationManager* NotificationManager::singletonRef_s = NULL;
51
52    /**
53    @brief
54        Constructor. Registers the Object.
55    */
56    NotificationManager::NotificationManager()
57    {
58        RegisterRootObject(NotificationManager);
59
60        assert(singletonRef_s == 0);
61        singletonRef_s = this;
62
63        this->highestIndex_ = 0;
64    }
65
66    /**
67    @brief
68        Destructor.
69    */
70    NotificationManager::~NotificationManager()
71    {
72    }
73
74    /**
75    @brief
76        Returns the current (and single) instance of the NotificationManager. Creates one, if there isn't one to begin with.
77    @return
78        Returns a reference to the single instance of the NotificationManager.
79    */
80    /*static*/ NotificationManager & NotificationManager::getInstance()
81    {
82        assert(singletonRef_s);
83        return *singletonRef_s;
84    }
85   
86    /**
87    @brief
88        Registers a Notification within the NotificationManager and makes sure that the Notification is displayed in all the NotificationQueues associated with its sender.
89    @param notification
90        The Notification to be registered.
91    @return
92        Returns true if successful.
93    */
94    bool NotificationManager::registerNotification(Notification* notification)
95    {
96   
97        if(notification == NULL) //!< A NULL-Notification cannot be registered.
98            return false;
99       
100        std::time_t time = std::time(0); //TDO: Doesn't this expire? //!< Get current time.
101       
102        this->allNotificationsList_.insert(std::pair<std::time_t,Notification*>(time,notification));
103       
104        if(notification->getSender() == NONE) //!< If the sender has no specific name, then the Notification is only added to the list of all Notifications.
105            return true;
106       
107        bool all = false;
108        if(notification->getSender() == ALL) //!< If all are the sender, then the Notifications is added to every NotificationQueue.
109            all = true;
110       
111        //!< Insert the notification in all queues that have its sender as target.
112        for(std::map<NotificationQueue*,int>::iterator it = this->queueList_.begin(); it != this->queueList_.end(); it++) //!< Iterate through all queues.
113        {
114            std::set<std::string> set = it->first->getTargetsSet();
115            if(all || set.find(notification->getSender()) != set.end() || set.find(ALL) != set.end()) //TDO: Make sure this works.
116            {
117                this->notificationLists_[it->second]->insert(std::pair<std::time_t,Notification*>(time,notification)); //!< Insert the Notification in the Notifications list of the current NotificationQueue.
118                it->first->update(notification, time); //!< Update the queue.
119            }
120        }
121       
122        COUT(3) << "Notification registered with the NotificationManager." << std::endl;
123       
124        return true;
125    }
126   
127    /**
128    @brief
129        Registers a NotificationQueue within the NotificationManager.
130    @param queue
131        The NotificationQueue to be registered.
132    @return
133        Returns true if successful.
134    */
135    bool NotificationManager::registerQueue(NotificationQueue* queue)
136    {
137        this->highestIndex_ += 1;
138        int index = this->highestIndex_;
139       
140        this->queueList_[queue] = index; //!< Add the NotificationQueue to the list of queues.
141       
142        std::set<std::string> set = queue->getTargetsSet(); //TDO: Works this?
143       
144        //! 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.
145        if(set.find(ALL) != set.end())
146        {
147            this->notificationLists_[index] = &this->allNotificationsList_;
148            COUT(3) << "NotificationQueue registered with the NotificationManager." << std::endl;
149            return true;
150        }
151       
152        this->notificationLists_[index] = new std::multimap<std::time_t,Notification*>;
153        std::multimap<std::time_t,Notification*> map = *this->notificationLists_[index];
154       
155        //! Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
156        for(std::multimap<std::time_t,Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
157        {
158            if(set.find(it->second->getSender()) != set.end()) //!< Checks whether the overlay has the sender of the current notification as target.
159            {
160                map.insert(std::pair<std::time_t,Notification*>(it->first, it->second));
161            }
162        }
163       
164        queue->update(); //!< Update the queue.
165
166        COUT(3) << "NotificationQueue registered with the NotificationManager." << std::endl;
167       
168        return true;
169    }
170   
171    /**
172    @brief
173        Fetches the Notifications for a specific NotificationQueue in a specified timeframe.
174    @param queue
175        The NotificationQueue the Notifications are fetched for.
176    @param map
177        A multimap, in which the notifications are stored.
178    @param timeFrameStart
179        The start time of the timeframe.
180    @param timeFrameEnd
181        The end time of the timeframe.
182    @return
183        Returns true if successful.
184    */
185    bool NotificationManager::getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
186    {
187        if(queue == NULL || map == NULL)
188            return false;
189
190        std::multimap<std::time_t,Notification*>* notifications = this->notificationLists_[this->queueList_[queue]]; //!< The Notifications for the input NotificationQueue.
191       
192        if(notifications == NULL) //!< Returns NULL, if there are no Notifications.
193            return true;
194   
195        std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest;
196        itLowest = notifications->lower_bound(timeFrameStart);
197        itHighest = notifications->upper_bound(timeFrameStart);
198       
199        for(it = itLowest; it != itHighest; it++) //!< Iterate through the Notifications from the start of the time Frame to the end of it.
200        {
201            map->insert(std::pair<std::time_t,Notification*>(it->first,it->second)); //!< Add the found Notifications to the map.
202        }
203       
204        return true;
205    }
206
207}
Note: See TracBrowser for help on using the repository browser.