Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/consolecommands/src/modules/questsystem/notifications/NotificationManager.cc @ 6518

Last change on this file since 6518 was 6182, checked in by rgrieder, 15 years ago

Singleton pointer initialisation should be part of the ManageScopedSingleton macro to ensure the order.

  • Property svn:eol-style set to native
File size: 7.1 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
31    @brief Implementation of the NotificationManager class.
32*/
33
34#include "NotificationManager.h"
35
36#include <set>
37
38#include "core/CoreIncludes.h"
39#include "core/ScopedSingletonManager.h"
40#include "Notification.h"
41#include "interfaces/NotificationListener.h"
42
43namespace orxonox
44{
45
46    const std::string NotificationManager::ALL = "all";
47    const std::string NotificationManager::NONE = "none";
48
49    ManageScopedSingleton(NotificationManager, ScopeID::Root, false);
50
51    /**
52    @brief
53        Constructor. Registers the Object.
54    */
55    NotificationManager::NotificationManager()
56    {
57        RegisterRootObject(NotificationManager);
58
59        this->highestIndex_ = 0;
60    }
61
62    /**
63    @brief
64        Destructor.
65    */
66    NotificationManager::~NotificationManager()
67    {
68    }
69
70    /**
71    @brief
72        Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationListeners associated with its sender.
73    @param notification
74        The Notification to be registered.
75    @return
76        Returns true if successful.
77    */
78    bool NotificationManager::registerNotification(Notification* notification)
79    {
80
81        if(notification == NULL) //!< A NULL-Notification cannot be registered.
82            return false;
83
84        std::time_t time = std::time(0); //TODO: Doesn't this expire? //!< Get current time.
85
86        this->allNotificationsList_.insert(std::pair<std::time_t,Notification*>(time,notification));
87
88        if(notification->getSender() == NONE) //!< If the sender has no specific name, then the Notification is only added to the list of all Notifications.
89            return true;
90
91        bool all = false;
92        if(notification->getSender() == ALL) //!< If all are the sender, then the Notifications is added to every NotificationListener.
93            all = true;
94
95        //!< Insert the notification in all listeners that have its sender as target.
96        for(std::map<NotificationListener*,int>::iterator it = this->listenerList_.begin(); it != this->listenerList_.end(); it++) //!< Iterate through all listeners.
97        {
98            std::set<std::string> set = it->first->getTargetsSet();
99            if(all || set.find(notification->getSender()) != set.end() || set.find(ALL) != set.end()) //TODO: Make sure this works.
100            {
101                this->notificationLists_[it->second]->insert(std::pair<std::time_t,Notification*>(time,notification)); //!< Insert the Notification in the Notifications list of the current NotificationListener.
102                it->first->update(notification, time); //!< Update the listener.
103            }
104        }
105
106        COUT(3) << "Notification registered with the NotificationManager." << std::endl;
107
108        return true;
109    }
110
111    /**
112    @brief
113        Registers a NotificationListener within the NotificationManager.
114    @param listener
115        The NotificationListener to be registered.
116    @return
117        Returns true if successful.
118    */
119    bool NotificationManager::registerListener(NotificationListener* listener)
120    {
121        this->highestIndex_ += 1;
122        int index = this->highestIndex_;
123
124        this->listenerList_[listener] = index; //!< Add the NotificationListener to the list of listeners.
125
126        std::set<std::string> set = listener->getTargetsSet(); //TODO: Does this work?
127
128        //! 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.
129        if(set.find(ALL) != set.end())
130        {
131            this->notificationLists_[index] = &this->allNotificationsList_;
132            COUT(3) << "NotificationListener registered with the NotificationManager." << std::endl;
133            return true;
134        }
135
136        this->notificationLists_[index] = new std::multimap<std::time_t,Notification*>;
137        std::multimap<std::time_t,Notification*> map = *this->notificationLists_[index];
138
139        //! Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationListener.
140        for(std::multimap<std::time_t,Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
141        {
142            if(set.find(it->second->getSender()) != set.end()) //!< Checks whether the overlay has the sender of the current notification as target.
143            {
144                map.insert(std::pair<std::time_t,Notification*>(it->first, it->second));
145            }
146        }
147
148        listener->update(); //!< Update the listener.
149
150        COUT(3) << "NotificationListener registered with the NotificationManager." << std::endl;
151
152        return true;
153    }
154
155    /**
156    @brief
157        Fetches the Notifications for a specific NotificationListener in a specified timeframe.
158    @param listener
159        The NotificationListener the Notifications are fetched for.
160    @param map
161        A multimap, in which the notifications are stored.
162    @param timeFrameStart
163        The start time of the timeframe.
164    @param timeFrameEnd
165        The end time of the timeframe.
166    @return
167        Returns true if successful.
168    */
169    bool NotificationManager::getNotifications(NotificationListener* listener, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
170    {
171        if(listener == NULL || map == NULL)
172            return false;
173
174        std::multimap<std::time_t,Notification*>* notifications = this->notificationLists_[this->listenerList_[listener]]; //!< The Notifications for the input NotificationListener.
175
176        if(notifications == NULL) //!< Returns NULL, if there are no Notifications.
177            return true;
178
179        std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest;
180        itLowest = notifications->lower_bound(timeFrameStart);
181        itHighest = notifications->upper_bound(timeFrameStart);
182
183        for(it = itLowest; it != itHighest; it++) //!< Iterate through the Notifications from the start of the time Frame to the end of it.
184        {
185            map->insert(std::pair<std::time_t,Notification*>(it->first,it->second)); //!< Add the found Notifications to the map.
186        }
187
188        return true;
189    }
190
191}
Note: See TracBrowser for help on using the repository browser.