src/Events/Events_Loop.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        Events_Loop.hxx
   4 // Created:     Thu Mar 13 2014
   5 // Author:      Mikhail PONIKAROV
   6
   7 #include <Events_Loop.h>
   8 #include <Events_MessageGroup.h>
   9
  10 #include <string>
  11 #include <cstring>
  12
  13 Events_Loop* Events_Loop::loop()
  14 {
  15   // initialized on initialization of the application
  16   static Events_Loop MAIN_LOOP;
  17   return &MAIN_LOOP;
  18 }
  19
  20 Events_ID Events_Loop::eventByName(const char* theName)
  21 {
  22   ///! All events created in this session, uniquely identified by the text and char pointer
  23   static std::map<std::string, char*> CREATED_EVENTS;
  24   char* aResult;
  25   std::string aName(theName);
  26   std::map<std::string, char*>::iterator aFound = CREATED_EVENTS.find(aName);
  27   if (aFound == CREATED_EVENTS.end()) {  //not created yet
  28 #ifdef WIN32
  29     aResult = _strdup(theName);  // copy to make unique internal pointer
  30 #else
  31     aResult = strdup(theName);  // copy to make unique internal pointer
  32 #endif
  33     CREATED_EVENTS[aName] = aResult;
  34   } else
  35     aResult = aFound->second;
  36
  37   return Events_ID(aResult);
  38 }
  39
  40 void Events_Loop::sendProcessEvent(const std::shared_ptr<Events_Message>& theMessage,
  41   std::list<Events_Listener*>& theListeners, const bool theFlushedNow)
  42 {
  43   std::list<Events_Listener*>::iterator aL = theListeners.begin();
  44   for (; aL != theListeners.end(); aL++) {
  45     if (theFlushedNow && (*aL)->groupMessages()) {
  46       (*aL)->groupWhileFlush(theMessage);
  47     } else {
  48       (*aL)->processEvent(theMessage);
  49     }
  50   }
  51 }
  52
  53 void Events_Loop::send(const std::shared_ptr<Events_Message>& theMessage, bool isGroup)
  54 {
  55   if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) {
  56     myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage);
  57   }
  58   // if it is grouped message, just accumulate it
  59   bool isFlushedNow = myFlushed.find(theMessage->eventID().myID) != myFlushed.end();
  60   if (isGroup && !isFlushedNow) {
  61     std::shared_ptr<Events_MessageGroup> aGroup =
  62       std::dynamic_pointer_cast<Events_MessageGroup>(theMessage);
  63     if (aGroup) {
  64       std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup = myGroups.find(
  65           aGroup->eventID().eventText());
  66       if (aMyGroup == myGroups.end()) {  // create a new group of messages for accumulation
  67         myGroups[aGroup->eventID().eventText()] = aGroup->newEmpty();
  68         aMyGroup = myGroups.find(aGroup->eventID().eventText());
  69       }
  70       std::shared_ptr<Events_MessageGroup> aStored =
  71         std::dynamic_pointer_cast<Events_MessageGroup>(aMyGroup->second);
  72       aStored->Join(aGroup);
  73       return;
  74     }
  75   }
  76   // send
  77   std::map<char*, std::map<void*, std::list<Events_Listener*> > >::iterator aFindID =
  78     myListeners.find(theMessage->eventID().eventText());
  79   if (aFindID != myListeners.end()) {
  80     std::map<void*, std::list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(
  81         theMessage->sender());
  82     if (aFindSender != aFindID->second.end()) {
  83       sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup);
  84     }
  85     if (theMessage->sender()) {  // also call for NULL senders registered
  86       aFindSender = aFindID->second.find(NULL);
  87       if (aFindSender != aFindID->second.end()) {
  88         sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup);
  89       }
  90     }
  91   }
  92 }
  93
  94 void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID theID,
  95                                    void* theSender, bool theImmediate)
  96 {
  97   if (theImmediate) { // just register as an immediate
  98     myImmediateListeners[theID.eventText()] = theListener;
  99     return;
 100   }
 101   std::map<char*, std::map<void*, std::list<Events_Listener*> > >::iterator aFindID =
 102     myListeners.find(theID.eventText());
 103   if (aFindID == myListeners.end()) {  // create container associated with ID
 104     myListeners[theID.eventText()] = std::map<void*, std::list<Events_Listener*> >();
 105     aFindID = myListeners.find(theID.eventText());
 106   }
 107
 108   std::map<void*, std::list<Events_Listener*> >::iterator aFindSender =
 109     aFindID->second.find(theSender);
 110   if (aFindSender == aFindID->second.end()) {  // create container associated with sender
 111     aFindID->second[theSender] = std::list<Events_Listener*>();
 112     aFindSender = aFindID->second.find(theSender);
 113   }
 114   // check that listener was not registered wit hsuch parameters before
 115   std::list<Events_Listener*>& aListeners = aFindSender->second;
 116   for (std::list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
 117     if (*aL == theListener)
 118       return;  // avoid duplicates
 119
 120   aListeners.push_back(theListener);
 121 }
 122
 123 void Events_Loop::removeListener(Events_Listener* theListener)
 124 {
 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;
 139           break;
 140         }
 141       }
 142       if (aListeners.empty()) {
 143         aLMap.erase(aLIt->first);
 144         myListeners[anIt->first] = aLMap;
 145         if (aLMap.empty())
 146           break; // avoid incrementation of the iterator if the the container is empty
 147       }
 148       aLIt++;
 149     }
 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
 154     }
 155     anIt++;
 156   }
 157
 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
 165     }
 166     anImIt++;
 167   }
 168 }
 169
 170 void Events_Loop::flush(const Events_ID& theID)
 171 {
 172   if (!myFlushActive)
 173     return;
 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()))
 177   {  // really sends
 178     bool aWasFlushed = myFlushed.find(theID.myID) != myFlushed.end();
 179     if (!aWasFlushed)
 180       myFlushed.insert(theID.myID);
 181     std::shared_ptr<Events_Message> aGroup = aMyGroup->second;
 182     myGroups.erase(aMyGroup);
 183     send(aGroup, false);
 184
 185     if (!aWasFlushed) {
 186       // TODO: Stabilization fix. Check later.
 187       if(myFlushed.find(theID.myID) != myFlushed.end()) {
 188         myFlushed.erase(myFlushed.find(theID.myID));
 189       } else {
 190         bool aProblem = true;
 191       }
 192     }
 193     // send accumulated messages to "groupListeners"
 194     std::map<char*, std::map<void*, std::list<Events_Listener*> > >::iterator aFindID =
 195       myListeners.find(theID.eventText());
 196     if (aFindID != myListeners.end()) {
 197       std::map<void*, std::list<Events_Listener*> >::iterator aFindSender =
 198         aFindID->second.begin();
 199       for(; aFindSender != aFindID->second.end(); aFindSender++) {
 200         std::list<Events_Listener*>::iterator aListener = aFindSender->second.begin();
 201         for(; aListener != aFindSender->second.end(); aListener++) {
 202           if ((*aListener)->groupMessages()) {
 203             (*aListener)->flushGrouped(theID);
 204           }
 205         }
 206       }
 207     }
 208   }
 209 }
 210
 211 void Events_Loop::eraseMessages(const Events_ID& theID)
 212 {
 213   std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup =
 214     myGroups.find(theID.eventText());
 215   if (aMyGroup != myGroups.end()) {
 216     myGroups.erase(aMyGroup);
 217   }
 218 }
 219
 220
 221 bool Events_Loop::activateFlushes(const bool theActivate)
 222 {
 223   bool isActive = myFlushActive;
 224   myFlushActive = theActivate;
 225   return isActive;
 226 }
 227
 228 void Events_Loop::clear(const Events_ID& theID)
 229 {
 230   std::map<char*, std::shared_ptr<Events_Message>>::iterator aMyGroup =
 231     myGroups.find(theID.eventText());
 232   if (aMyGroup != myGroups.end()) {  // really sends
 233     myGroups.erase(aMyGroup);
 234   }
 235 }
 236
 237 void Events_Loop::autoFlush(const Events_ID& theID, const bool theAuto)
 238 {
 239   if (theAuto)
 240     myFlushed.insert(theID.myID);
 241   else
 242     myFlushed.erase(myFlushed.find(theID.myID));
 243 }
 244
 245 bool Events_Loop::isFlushed(const Events_ID& theID)
 246 {
 247   return myFlushed.find(theID.myID) != myFlushed.end();
 248 }
 249
 250 void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue)
 251 {
 252   if (theValue)
 253     myFlushed.insert(theID.myID);
 254   else
 255     myFlushed.erase(myFlushed.find(theID.myID));
 256 }