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::send(const std::shared_ptr<Events_Message>& theMessage, bool isGroup)
  43 {
  44   if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) {
  45     myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage);
  46   }
  47   // if it is grouped message, just accumulate it
  48   if (isGroup && myFlushed.find(theMessage->eventID().myID) == myFlushed.end()) {
  49     std::shared_ptr<Events_MessageGroup> aGroup =
  50       std::dynamic_pointer_cast<Events_MessageGroup>(theMessage);
  51     if (aGroup) {
  52       std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup = myGroups.find(
  53           aGroup->eventID().eventText());
  54       if (aMyGroup == myGroups.end()) {  // create a new group of messages for accumulation
  55         myGroups[aGroup->eventID().eventText()] = aGroup->newEmpty();
  56         aMyGroup = myGroups.find(aGroup->eventID().eventText());
  57       }
  58       std::shared_ptr<Events_MessageGroup> aStored =
  59         std::dynamic_pointer_cast<Events_MessageGroup>(aMyGroup->second);
  60       aStored->Join(aGroup);
  61       return;
  62     }
  63   }
  64
  65   // TODO: make it in thread and with usage of semaphores
  66
  67   map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
  68       theMessage->eventID().eventText());
  69   if (aFindID != myListeners.end()) {
  70     map<void*, list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(
  71         theMessage->sender());
  72     if (aFindSender != aFindID->second.end()) {
  73       list<Events_Listener*>& aListeners = aFindSender->second;
  74       for (list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
  75         (*aL)->processEvent(theMessage);
  76     }
  77     if (theMessage->sender()) {  // also call for NULL senders registered
  78       aFindSender = aFindID->second.find(NULL);
  79       if (aFindSender != aFindID->second.end()) {
  80         list<Events_Listener*>& aListeners = aFindSender->second;
  81         for (list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
  82           (*aL)->processEvent(theMessage);
  83       }
  84     }
  85   }
  86 }
  87
  88 void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID theID,
  89                                    void* theSender, bool theImmediate)
  90 {
  91   if (theImmediate) { // just register as an immediate
  92     myImmediateListeners[theID.eventText()] = theListener;
  93     return;
  94   }
  95   map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
  96       theID.eventText());
  97   if (aFindID == myListeners.end()) {  // create container associated with ID
  98     myListeners[theID.eventText()] = map<void*, list<Events_Listener*> >();
  99     aFindID = myListeners.find(theID.eventText());
 100   }
 101
 102   map<void*, list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(theSender);
 103   if (aFindSender == aFindID->second.end()) {  // create container associated with sender
 104     aFindID->second[theSender] = list<Events_Listener*>();
 105     aFindSender = aFindID->second.find(theSender);
 106   }
 107   // check that listener was not registered wit hsuch parameters before
 108   list<Events_Listener*>& aListeners = aFindSender->second;
 109   for (list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
 110     if (*aL == theListener)
 111       return;  // avoid duplicates
 112
 113   aListeners.push_back(theListener);
 114 }
 115
 116 void Events_Loop::removeListener(Events_Listener* theListener)
 117 {
 118   // remove the listener in myListeners map
 119   std::map<char*, std::map<void*, std::list<Events_Listener*> > >::const_reverse_iterator
 120                                                           anIt = myListeners.rbegin();
 121   while(anIt != myListeners.rend()) {
 122     std::map<void*, std::list<Events_Listener*> > aLMap = anIt->second;
 123     std::map<void*, std::list<Events_Listener*> >::const_reverse_iterator aLIt = aLMap.rbegin();
 124     while (aLIt != aLMap.rend()) {
 125       std::list<Events_Listener*> aListeners = aLIt->second;
 126       std::list<Events_Listener*>::const_reverse_iterator aLsIt = aListeners.rbegin();
 127       for (; aLsIt != aListeners.rend(); aLsIt++) {
 128         if (*aLsIt == theListener) {
 129           aListeners.remove(theListener);
 130           aLMap[aLIt->first] = aListeners;
 131           myListeners[anIt->first] = aLMap;
 132           break;
 133         }
 134       }
 135       if (aListeners.empty()) {
 136         aLMap.erase(aLIt->first);
 137         myListeners[anIt->first] = aLMap;
 138         if (aLMap.empty())
 139           break; // avoid incrementation of the iterator if the the container is empty
 140       }
 141       aLIt++;
 142     }
 143     if (anIt->second.empty()) {
 144       myListeners.erase(anIt->first);
 145       if (myListeners.empty())
 146         break; // avoid incrementation of the iterator if the the container is empty
 147     }
 148     anIt++;
 149   }
 150
 151   // remove the listener in myImmediateListeners map
 152   std::map<char*, Events_Listener*>::const_reverse_iterator anImIt = myImmediateListeners.rbegin();
 153   while(anImIt != myImmediateListeners.rend()) {
 154     if (anImIt->second == theListener) {
 155       myImmediateListeners.erase(anImIt->first);
 156       if (myImmediateListeners.empty())
 157         break; // avoid incrementation of the iterator if the the container is empty
 158     }
 159     anImIt++;
 160   }
 161 }
 162
 163 void Events_Loop::flush(const Events_ID& theID)
 164 {
 165   if (!myFlushActive)
 166     return;
 167   std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup;
 168   for(aMyGroup = myGroups.find(theID.eventText());
 169     aMyGroup != myGroups.end(); aMyGroup = myGroups.find(theID.eventText()))
 170   {  // really sends
 171     bool aWasFlushed = myFlushed.find(theID.myID) != myFlushed.end();
 172     if (!aWasFlushed)
 173       myFlushed.insert(theID.myID);
 174     std::shared_ptr<Events_Message> aGroup = aMyGroup->second;
 175     myGroups.erase(aMyGroup);
 176     send(aGroup, false);
 177
 178     if (!aWasFlushed)
 179       // TODO: Stabilization fix. Check later.
 180       if(myFlushed.find(theID.myID) != myFlushed.end()) {
 181         myFlushed.erase(myFlushed.find(theID.myID));
 182       }
 183   }
 184 }
 185
 186 void Events_Loop::eraseMessages(const Events_ID& theID)
 187 {
 188   std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup =
 189     myGroups.find(theID.eventText());
 190   if (aMyGroup != myGroups.end()) {
 191     myGroups.erase(aMyGroup);
 192   }
 193 }
 194
 195
 196 bool Events_Loop::activateFlushes(const bool theActivate)
 197 {
 198   bool isActive = myFlushActive;
 199   myFlushActive = theActivate;
 200   return isActive;
 201 }
 202
 203 void Events_Loop::clear(const Events_ID& theID)
 204 {
 205   std::map<char*, std::shared_ptr<Events_Message>>::iterator aMyGroup =
 206     myGroups.find(theID.eventText());
 207   if (aMyGroup != myGroups.end()) {  // really sends
 208     myGroups.erase(aMyGroup);
 209   }
 210 }
 211
 212 void Events_Loop::autoFlush(const Events_ID& theID, const bool theAuto)
 213 {
 214   if (theAuto)
 215     myFlushed.insert(theID.myID);
 216   else
 217     myFlushed.erase(myFlushed.find(theID.myID));
 218 }
 219
 220 bool Events_Loop::isFlushed(const Events_ID& theID)
 221 {
 222   return myFlushed.find(theID.myID) != myFlushed.end();
 223 }
 224
 225 void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue)
 226 {
 227   if (theValue)
 228     myFlushed.insert(theID.myID);
 229   else
 230     myFlushed.erase(myFlushed.find(theID.myID));
 231 }