source: nrEngine/src/EventManager.cpp @ 1

Revision 1, 5.9 KB checked in by art, 13 years ago (diff)
Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13//----------------------------------------------------------------------------------
14// Includes
15//----------------------------------------------------------------------------------
16#include "EventManager.h"
17#include "Log.h"
18#include "Profiler.h"
19#include "ITask.h"
20#include "EventChannel.h"
21#include "Event.h"
22#include "EventFactory.h"
23
24
25namespace nrEngine{
26
27        //------------------------------------------------------------------------
28        EventManager::EventManager(){
29                setTaskName("EventSystem");
30
31                NR_Log(Log::LOG_ENGINE, "EventManager: Initialize the event management system");
32
33                // create default system wide channel
34                createChannel(NR_DEFAULT_EVENT_CHANNEL);
35        }
36
37        //------------------------------------------------------------------------
38        EventManager::~EventManager()
39        {
40                // clear the database, so all channels are deleted
41                mChannelDb.clear();
42
43                // clear the factory list
44                mFactoryDb.clear();
45        }
46
47        //------------------------------------------------------------------------
48        Result EventManager::createChannel(const std::string& name)
49        {
50                // check first whenever such a channel is already in the database
51                if (getChannel(name)) return EVENT_CHANNEL_EXISTS;
52
53                // channel is not in the database, so create it and fill it's data
54                SharedPtr<EventChannel> channel(new EventChannel(this, name));
55
56                // push the channel into the database
57                mChannelDb[name] = channel;
58                NR_Log(Log::LOG_ENGINE, "EventManager: New channel \"%s\" created", name.c_str());
59
60                // OK
61                return OK;
62        }
63
64        //------------------------------------------------------------------------
65        Result EventManager::removeChannel(const std::string& name)
66        {
67                // check first whenever such a channel is already in the database
68                SharedPtr<EventChannel> channel = getChannel(name);
69                if (!channel) return EVENT_CHANNEL_NOT_EXISTS;
70
71                // disconnect all the actor from the channel
72                channel->_disconnectAll();
73                mChannelDb.erase(mChannelDb.find(name));
74
75                // log info
76                NR_Log(Log::LOG_ENGINE, "EventManager: Remove channel \"%s\"", name.c_str());
77
78                // OK
79                return OK;
80        }
81
82        //------------------------------------------------------------------------
83        SharedPtr<EventChannel> EventManager::getChannel(const std::string& name)
84        {
85                // search for such an entry in the db
86                ChannelDatabase::iterator it = mChannelDb.find(name);
87
88                if (it == mChannelDb.end()) return SharedPtr<EventChannel>();
89
90                return it->second;
91        }
92
93        //------------------------------------------------------------------------
94        Result EventManager::updateTask()
95        {
96
97                // go through each channel and deliver the messages
98                ChannelDatabase::iterator it = mChannelDb.begin();
99                for (; it != mChannelDb.end(); it++)
100                        it->second->deliver();
101
102                // ok
103                return OK;
104        }
105
106        //------------------------------------------------------------------------
107        Result EventManager::emit(const std::string& name, SharedPtr<Event> event)
108        {
109                // Profiling of the engine
110                _nrEngineProfile("EventManager.emit");
111
112                // if user want to send the message to all channels
113                if (name.length() == 0){
114                        ChannelDatabase::iterator it = mChannelDb.begin();
115                        for (; it != mChannelDb.end(); it++)
116                                it->second->push(event);
117
118                }else{
119                        // get the channel according to the name and emit the message
120                        SharedPtr<EventChannel> channel = getChannel(name);
121                        if (channel == NULL)
122                                return EVENT_CHANNEL_NOT_EXISTS;
123
124                        channel->push(event);
125                }
126
127                // ok
128                return OK;
129        }
130
131        //------------------------------------------------------------------------
132        Result EventManager::emitSystem(SharedPtr<Event> event)
133        {
134                return emit(NR_DEFAULT_EVENT_CHANNEL, event);
135        }
136
137
138        //------------------------------------------------------------------------
139        SharedPtr<Event> EventManager::createEvent(const std::string& eventType)
140        {
141                // find the factory, able to create this kind of events
142                FactoryDatabase::iterator it = mFactoryDb.begin();
143                for (; it != mFactoryDb.end(); it++){
144                        if (it->second->isSupported(eventType))
145                                return it->second->create(eventType);
146                }
147
148                return SharedPtr<Event>();
149        }
150
151        //------------------------------------------------------------------------
152        Result EventManager::registerFactory(const std::string& name, SharedPtr<EventFactory> factory)
153        {
154                // get a factory by name
155                FactoryDatabase::iterator it = mFactoryDb.find(name);
156                if (it != mFactoryDb.end()){
157                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "EventManager: The event factory %s is already registered", name.c_str());
158                        return EVENT_FACTORY_FOUND;
159                }
160
161                NR_Log(Log::LOG_ENGINE, Log::LL_NORMAL, "EventManager: Register event factory %s", name.c_str());
162                mFactoryDb[name] = factory;
163                return OK;
164        }
165
166        //------------------------------------------------------------------------
167        Result EventManager::removeFactory(const std::string& name)
168        {
169                // check if the the factory list is not empty
170                if (mFactoryDb.size() == 0) return OK;
171
172                // get a factory by name
173                FactoryDatabase::iterator it = mFactoryDb.find(name);
174                if (it == mFactoryDb.end()){
175                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "EventManager: The event factory %s was not found", name.c_str());
176                        return EVENT_FACTORY_NOT_FOUND;
177                }
178                NR_Log(Log::LOG_ENGINE, Log::LL_NORMAL, "EventManager: Remove event factory %s", name.c_str());
179                mFactoryDb.erase(it);
180                return OK;
181        }
182
183}; // end namespace
184
Note: See TracBrowser for help on using the repository browser.