source: nrEngine/src/EventManager.cpp @ 37

Revision 37, 6.2 KB checked in by art, 13 years ago (diff)

good

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
113                // if user want to send the message to all channels
114                if (name.length() == 0){
115                        NR_Log(Log::LOG_ENGINE, Log::LL_CHATTY, "EventManager: Emit event '%s' to all channels", event->getEventType());
116                        ChannelDatabase::iterator it = mChannelDb.begin();
117                        for (; it != mChannelDb.end(); it++)
118                                it->second->push(event);
119
120                }else{
121                        NR_Log(Log::LOG_ENGINE, Log::LL_CHATTY, "EventManager: Emit event '%s' to '%s'", event->getEventType(), name.c_str());
122                        // get the channel according to the name and emit the message
123                        SharedPtr<EventChannel> channel = getChannel(name);
124                        if (channel == NULL)
125                                return EVENT_CHANNEL_NOT_EXISTS;
126
127                        channel->push(event);
128                }
129
130                // ok
131                return OK;
132        }
133
134        //------------------------------------------------------------------------
135        Result EventManager::emitSystem(SharedPtr<Event> event)
136        {
137                return emit(NR_DEFAULT_EVENT_CHANNEL, event);
138        }
139
140
141        //------------------------------------------------------------------------
142        SharedPtr<Event> EventManager::createEvent(const std::string& eventType)
143        {
144                // find the factory, able to create this kind of events
145                FactoryDatabase::iterator it = mFactoryDb.begin();
146                for (; it != mFactoryDb.end(); it++){
147                        if (it->second->isSupported(eventType))
148                                return it->second->create(eventType);
149                }
150
151                return SharedPtr<Event>();
152        }
153
154        //------------------------------------------------------------------------
155        Result EventManager::registerFactory(const std::string& name, SharedPtr<EventFactory> factory)
156        {
157                // get a factory by name
158                FactoryDatabase::iterator it = mFactoryDb.find(name);
159                if (it != mFactoryDb.end()){
160                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "EventManager: The event factory %s is already registered", name.c_str());
161                        return EVENT_FACTORY_FOUND;
162                }
163
164                NR_Log(Log::LOG_ENGINE, Log::LL_NORMAL, "EventManager: Register event factory %s", name.c_str());
165                mFactoryDb[name] = factory;
166                return OK;
167        }
168
169        //------------------------------------------------------------------------
170        Result EventManager::removeFactory(const std::string& name)
171        {
172                // check if the the factory list is not empty
173                if (mFactoryDb.size() == 0) return OK;
174
175                // get a factory by name
176                FactoryDatabase::iterator it = mFactoryDb.find(name);
177                if (it == mFactoryDb.end()){
178                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "EventManager: The event factory %s was not found", name.c_str());
179                        return EVENT_FACTORY_NOT_FOUND;
180                }
181                NR_Log(Log::LOG_ENGINE, Log::LL_NORMAL, "EventManager: Remove event factory %s", name.c_str());
182                mFactoryDb.erase(it);
183                return OK;
184        }
185
186}; // end namespace
187
Note: See TracBrowser for help on using the repository browser.