1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
3 // File: Events_Loop.hxx
4 // Created: Thu Mar 13 2014
5 // Author: Mikhail PONIKAROV
7 #include <Events_Loop.h>
8 #include <Events_MessageGroup.h>
15 Events_Loop* Events_Loop::loop()
17 // initialized on initialization of the application
18 static Events_Loop MAIN_LOOP;
22 Events_ID Events_Loop::eventByName(const char* theName)
24 ///! All events created in this session, uniquely identified by the text and char pointer
25 static map<string, char*> CREATED_EVENTS;
27 string aName(theName);
28 map<string, char*>::iterator aFound = CREATED_EVENTS.find(aName);
29 if (aFound == CREATED_EVENTS.end()) { //not created yet
31 aResult = _strdup(theName); // copy to make unique internal pointer
33 aResult = strdup(theName); // copy to make unique internal pointer
35 CREATED_EVENTS[aName] = aResult;
37 aResult = aFound->second;
39 return Events_ID(aResult);
42 void Events_Loop::sendProcessEvent(const std::shared_ptr<Events_Message>& theMessage,
43 std::list<Events_Listener*>& theListeners, const bool theFlushedNow)
45 for (list<Events_Listener*>::iterator aL = theListeners.begin(); aL != theListeners.end(); aL++) {
46 if (theFlushedNow && (*aL)->groupMessages()) {
47 (*aL)->groupWhileFlush(theMessage);
49 (*aL)->processEvent(theMessage);
54 void Events_Loop::send(const std::shared_ptr<Events_Message>& theMessage, bool isGroup)
56 if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) {
57 myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage);
59 // if it is grouped message, just accumulate it
60 bool isFlushedNow = myFlushed.find(theMessage->eventID().myID) != myFlushed.end();
61 if (isGroup && !isFlushedNow) {
62 std::shared_ptr<Events_MessageGroup> aGroup =
63 std::dynamic_pointer_cast<Events_MessageGroup>(theMessage);
65 std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup = myGroups.find(
66 aGroup->eventID().eventText());
67 if (aMyGroup == myGroups.end()) { // create a new group of messages for accumulation
68 myGroups[aGroup->eventID().eventText()] = aGroup->newEmpty();
69 aMyGroup = myGroups.find(aGroup->eventID().eventText());
71 std::shared_ptr<Events_MessageGroup> aStored =
72 std::dynamic_pointer_cast<Events_MessageGroup>(aMyGroup->second);
73 aStored->Join(aGroup);
78 map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
79 theMessage->eventID().eventText());
80 if (aFindID != myListeners.end()) {
81 map<void*, list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(
82 theMessage->sender());
83 if (aFindSender != aFindID->second.end()) {
84 sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup);
86 if (theMessage->sender()) { // also call for NULL senders registered
87 aFindSender = aFindID->second.find(NULL);
88 if (aFindSender != aFindID->second.end()) {
89 sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup);
95 void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID theID,
96 void* theSender, bool theImmediate)
98 if (theImmediate) { // just register as an immediate
99 myImmediateListeners[theID.eventText()] = theListener;
102 map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
104 if (aFindID == myListeners.end()) { // create container associated with ID
105 myListeners[theID.eventText()] = map<void*, list<Events_Listener*> >();
106 aFindID = myListeners.find(theID.eventText());
109 map<void*, list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(theSender);
110 if (aFindSender == aFindID->second.end()) { // create container associated with sender
111 aFindID->second[theSender] = list<Events_Listener*>();
112 aFindSender = aFindID->second.find(theSender);
114 // check that listener was not registered wit hsuch parameters before
115 list<Events_Listener*>& aListeners = aFindSender->second;
116 for (list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
117 if (*aL == theListener)
118 return; // avoid duplicates
120 aListeners.push_back(theListener);
123 void Events_Loop::removeListener(Events_Listener* theListener)
125 // remove the listener in myListeners map
126 std::map<char*, std::map<void*, std::list<Events_Listener*> > >::const_reverse_iterator
127 anIt = myListeners.rbegin();
128 while(anIt != myListeners.rend()) {
129 std::map<void*, std::list<Events_Listener*> > aLMap = anIt->second;
130 std::map<void*, std::list<Events_Listener*> >::const_reverse_iterator aLIt = aLMap.rbegin();
131 while (aLIt != aLMap.rend()) {
132 std::list<Events_Listener*> aListeners = aLIt->second;
133 std::list<Events_Listener*>::const_reverse_iterator aLsIt = aListeners.rbegin();
134 for (; aLsIt != aListeners.rend(); aLsIt++) {
135 if (*aLsIt == theListener) {
136 aListeners.remove(theListener);
137 aLMap[aLIt->first] = aListeners;
138 myListeners[anIt->first] = aLMap;
142 if (aListeners.empty()) {
143 aLMap.erase(aLIt->first);
144 myListeners[anIt->first] = aLMap;
146 break; // avoid incrementation of the iterator if the the container is empty
150 if (anIt->second.empty()) {
151 myListeners.erase(anIt->first);
152 if (myListeners.empty())
153 break; // avoid incrementation of the iterator if the the container is empty
158 // remove the listener in myImmediateListeners map
159 std::map<char*, Events_Listener*>::const_reverse_iterator anImIt = myImmediateListeners.rbegin();
160 while(anImIt != myImmediateListeners.rend()) {
161 if (anImIt->second == theListener) {
162 myImmediateListeners.erase(anImIt->first);
163 if (myImmediateListeners.empty())
164 break; // avoid incrementation of the iterator if the the container is empty
170 void Events_Loop::flush(const Events_ID& theID)
174 std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup;
175 for(aMyGroup = myGroups.find(theID.eventText());
176 aMyGroup != myGroups.end(); aMyGroup = myGroups.find(theID.eventText()))
178 bool aWasFlushed = myFlushed.find(theID.myID) != myFlushed.end();
180 myFlushed.insert(theID.myID);
181 std::shared_ptr<Events_Message> aGroup = aMyGroup->second;
182 myGroups.erase(aMyGroup);
186 // TODO: Stabilization fix. Check later.
187 if(myFlushed.find(theID.myID) != myFlushed.end()) {
188 myFlushed.erase(myFlushed.find(theID.myID));
190 bool aProblem = true;
193 // send accumulated messages to "groupListeners"
194 map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
196 if (aFindID != myListeners.end()) {
197 map<void*, list<Events_Listener*> >::iterator aFindSender = aFindID->second.begin();
198 for(; aFindSender != aFindID->second.end(); aFindSender++) {
199 list<Events_Listener*>::iterator aListener = aFindSender->second.begin();
200 for(; aListener != aFindSender->second.end(); aListener++) {
201 if ((*aListener)->groupMessages()) {
202 (*aListener)->flushGrouped(theID);
210 void Events_Loop::eraseMessages(const Events_ID& theID)
212 std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup =
213 myGroups.find(theID.eventText());
214 if (aMyGroup != myGroups.end()) {
215 myGroups.erase(aMyGroup);
220 bool Events_Loop::activateFlushes(const bool theActivate)
222 bool isActive = myFlushActive;
223 myFlushActive = theActivate;
227 void Events_Loop::clear(const Events_ID& theID)
229 std::map<char*, std::shared_ptr<Events_Message>>::iterator aMyGroup =
230 myGroups.find(theID.eventText());
231 if (aMyGroup != myGroups.end()) { // really sends
232 myGroups.erase(aMyGroup);
236 void Events_Loop::autoFlush(const Events_ID& theID, const bool theAuto)
239 myFlushed.insert(theID.myID);
241 myFlushed.erase(myFlushed.find(theID.myID));
244 bool Events_Loop::isFlushed(const Events_ID& theID)
246 return myFlushed.find(theID.myID) != myFlushed.end();
249 void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue)
252 myFlushed.insert(theID.myID);
254 myFlushed.erase(myFlushed.find(theID.myID));