Fix for the issue #1647 : problem with OB when sub-features are created.

[modules/shaper.git] / src / Events / Events_Loop.cpp

diff --git a/src/Events/Events_Loop.cpp b/src/Events/Events_Loop.cpp
index f9ccd81eca3e7857cf3b5849e261fa93d823db3c..e68798aa43c31f7e341af66bd32d60aba00f37f0 100644 (file)
--- a/src/Events/Events_Loop.cpp
+++ b/src/Events/Events_Loop.cpp
@@ -1,3 +1,5 @@
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
 // File:       Events_Loop.hxx
 // Created:    Thu Mar 13 2014
 // Author:     Mikhail PONIKAROV
@@ -60,8 +62,6 @@ void Events_Loop::send(const std::shared_ptr<Events_Message>& theMessage, bool i
     }
   }
 
-  // TODO: make it in thread and with usage of semaphores
-
   map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
       theMessage->eventID().eventText());
   if (aFindID != myListeners.end()) {
@@ -111,26 +111,91 @@ void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID
   aListeners.push_back(theListener);
 }
 
+void Events_Loop::removeListener(Events_Listener* theListener)
+{
+  // remove the listener in myListeners map
+  std::map<char*, std::map<void*, std::list<Events_Listener*> > >::const_reverse_iterator
+                                                          anIt = myListeners.rbegin();
+  while(anIt != myListeners.rend()) {
+    std::map<void*, std::list<Events_Listener*> > aLMap = anIt->second;
+    std::map<void*, std::list<Events_Listener*> >::const_reverse_iterator aLIt = aLMap.rbegin();
+    while (aLIt != aLMap.rend()) {
+      std::list<Events_Listener*> aListeners = aLIt->second;
+      std::list<Events_Listener*>::const_reverse_iterator aLsIt = aListeners.rbegin();
+      for (; aLsIt != aListeners.rend(); aLsIt++) {
+        if (*aLsIt == theListener) {
+          aListeners.remove(theListener);
+          aLMap[aLIt->first] = aListeners;
+          myListeners[anIt->first] = aLMap;
+          break;
+        }
+      }
+      if (aListeners.empty()) {
+        aLMap.erase(aLIt->first);
+        myListeners[anIt->first] = aLMap;
+        if (aLMap.empty())
+          break; // avoid incrementation of the iterator if the the container is empty
+      }
+      aLIt++;
+    }
+    if (anIt->second.empty()) {
+      myListeners.erase(anIt->first);
+      if (myListeners.empty())
+        break; // avoid incrementation of the iterator if the the container is empty
+    }
+    anIt++;
+  }
+
+  // remove the listener in myImmediateListeners map
+  std::map<char*, Events_Listener*>::const_reverse_iterator anImIt = myImmediateListeners.rbegin();
+  while(anImIt != myImmediateListeners.rend()) {
+    if (anImIt->second == theListener) {
+      myImmediateListeners.erase(anImIt->first);
+      if (myImmediateListeners.empty())
+        break; // avoid incrementation of the iterator if the the container is empty
+    }
+    anImIt++;
+  }
+}
+
 void Events_Loop::flush(const Events_ID& theID)
 {
   if (!myFlushActive)
     return;
-  std::map<char*, std::shared_ptr<Events_Message>>::iterator aMyGroup =
-    myGroups.find(theID.eventText());
-  if (aMyGroup != myGroups.end()) {  // really sends
-    myFlushed.insert(theID.myID);
+  std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup;
+  for(aMyGroup = myGroups.find(theID.eventText());
+    aMyGroup != myGroups.end(); aMyGroup = myGroups.find(theID.eventText()))
+  {  // really sends
+    bool aWasFlushed = myFlushed.find(theID.myID) != myFlushed.end();
+    if (!aWasFlushed)
+      myFlushed.insert(theID.myID);
     std::shared_ptr<Events_Message> aGroup = aMyGroup->second;
     myGroups.erase(aMyGroup);
     send(aGroup, false);
-    std::set<char*>::iterator anIt = myFlushed.find(theID.myID);
-    if (anIt != myFlushed.end())
-      myFlushed.erase(myFlushed.find(theID.myID));
+
+    if (!aWasFlushed)
+      // TODO: Stabilization fix. Check later.
+      if(myFlushed.find(theID.myID) != myFlushed.end()) {
+        myFlushed.erase(myFlushed.find(theID.myID));
+      }
   }
 }
 
-void Events_Loop::activateFlushes(const bool theActivate)
+void Events_Loop::eraseMessages(const Events_ID& theID)
 {
+  std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup =
+    myGroups.find(theID.eventText());
+  if (aMyGroup != myGroups.end()) {
+    myGroups.erase(aMyGroup);
+  }
+}
+
+
+bool Events_Loop::activateFlushes(const bool theActivate)
+{
+  bool isActive = myFlushActive;
   myFlushActive = theActivate;
+  return isActive;
 }
 
 void Events_Loop::clear(const Events_ID& theID)
@@ -149,3 +214,16 @@ void Events_Loop::autoFlush(const Events_ID& theID, const bool theAuto)
   else
     myFlushed.erase(myFlushed.find(theID.myID));
 }
+
+bool Events_Loop::isFlushed(const Events_ID& theID)
+{
+  return myFlushed.find(theID.myID) != myFlushed.end();
+}
+
+void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue)
+{
+  if (theValue)
+    myFlushed.insert(theID.myID);
+  else
+    myFlushed.erase(myFlushed.find(theID.myID));
+}