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 using namespace std;
  14
  15 Events_Loop* Events_Loop::loop()
  16 {
  17   // initialized on initialization of the application
  18   static Events_Loop MAIN_LOOP;
  19   return &MAIN_LOOP;
  20 }
  21
  22 Events_ID Events_Loop::eventByName(const char* theName)
  23 {
  24   ///! All events created in this session, uniquely identified by the text and char pointer
  25   static map<string, char*> CREATED_EVENTS;
  26   char* aResult;
  27   string aName(theName);
  28   map<string, char*>::iterator aFound = CREATED_EVENTS.find(aName);
  29   if (aFound == CREATED_EVENTS.end()) {  //not created yet
  30 #ifdef WIN32
  31     aResult = _strdup(theName);  // copy to make unique internal pointer
  32 #else
  33     aResult = strdup(theName);  // copy to make unique internal pointer
  34 #endif
  35     CREATED_EVENTS[aName] = aResult;
  36   } else
  37     aResult = aFound->second;
  38
  39   return Events_ID(aResult);
  40 }
  41
  42 void Events_Loop::sendProcessEvent(const std::shared_ptr<Events_Message>& theMessage,
  43   std::list<Events_Listener*>& theListeners, const bool theFlushedNow)
  44 {
  45   for (list<Events_Listener*>::iterator aL = theListeners.begin(); aL != theListeners.end(); aL++) {
  46     if (theFlushedNow && (*aL)->groupMessages()) {
  47       (*aL)->groupWhileFlush(theMessage);
  48     } else {
  49       (*aL)->processEvent(theMessage);
  50     }
  51   }
  52 }
  53
  54 void Events_Loop::send(const std::shared_ptr<Events_Message>& theMessage, bool isGroup)
  55 {
  56   if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) {
  57     myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage);
  58   }
  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);
  64     if (aGroup) {
  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());
  70       }
  71       std::shared_ptr<Events_MessageGroup> aStored =
  72         std::dynamic_pointer_cast<Events_MessageGroup>(aMyGroup->second);
  73       aStored->Join(aGroup);
  74       return;
  75     }
  76   }
  77   // send
  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);
  85     }
  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);
  90       }
  91     }
  92   }
  93 }
  94
  95 void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID theID,
  96                                    void* theSender, bool theImmediate)
  97 {
  98   if (theImmediate) { // just register as an immediate
  99     myImmediateListeners[theID.eventText()] = theListener;
 100     return;
 101   }
 102   map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
 103       theID.eventText());
 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());
 107   }
 108
 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);
 113   }
 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
 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     map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
 195       theID.eventText());
 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);
 203           }
 204         }
 205       }
 206     }
 207   }
 208 }
 209
 210 void Events_Loop::eraseMessages(const Events_ID& theID)
 211 {
 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);
 216   }
 217 }
 218
 219
 220 bool Events_Loop::activateFlushes(const bool theActivate)
 221 {
 222   bool isActive = myFlushActive;
 223   myFlushActive = theActivate;
 224   return isActive;
 225 }
 226
 227 void Events_Loop::clear(const Events_ID& theID)
 228 {
 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);
 233   }
 234 }
 235
 236 void Events_Loop::autoFlush(const Events_ID& theID, const bool theAuto)
 237 {
 238   if (theAuto)
 239     myFlushed.insert(theID.myID);
 240   else
 241     myFlushed.erase(myFlushed.find(theID.myID));
 242 }
 243
 244 bool Events_Loop::isFlushed(const Events_ID& theID)
 245 {
 246   return myFlushed.find(theID.myID) != myFlushed.end();
 247 }
 248
 249 void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue)
 250 {
 251   if (theValue)
 252     myFlushed.insert(theID.myID);
 253   else
 254     myFlushed.erase(myFlushed.find(theID.myID));
 255 }