Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/modules/questsystem/notifications/NotificationManager.cc @ 6323

Last change on this file since 6323 was 5929, checked in by rgrieder, 15 years ago

Merged core5 branch back to the trunk.
Key features include clean level unloading and an extended XML event system.

Two important notes:
Delete your keybindings.ini files! * or you will still get parser errors when loading the key bindings.
Delete build_dir/lib/modules/libgamestates.module! * or orxonox won't start.
Best thing to do is to delete the build folder ;)

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