Changeset 454bc54 for src/Observer/Notification.cpp

Timestamp:

Oct 30, 2015, 11:43:01 AM (10 years ago)

Author:

Frederik Heber <heber@…>

Children:

e24dde

Parents:

1b5188

git-author:

Frederik Heber <heber@…> (06/19/15 22:28:24)

git-committer:

Frederik Heber <heber@…> (10/30/15 11:43:01)

Message:

Added new pattern ObservedValue, contrary to Cacheable.

• essentially updates immediately and caches a value for off-line use, safe- guard with mutexes.
• added unit test for ObservedValue.
• factored threeNumbers stub out of CacheableUnitTest, also used the stub in ObservedValueUnitTest.
• we may now signOn() to Notification with a priority.
• Cacheable can also update now via notification channels not just for global updates.
• Observable can now also instantiate the channels directly if given a list. This was necessary as Cacheable or ObservedValue are instantiated in the constructor, too, and if listening to channels, these must already be present.
• FIX: Channels::addChannels() used NDEBUG wrong way round.
• ObservedValue::get() returns reference.

File:

• src/Observer/Notification.cpp (modified) (3 diffs)

src/Observer/Notification.cpp

@@ -20 +20 @@
 #include "CodePatterns/MemDebug.hpp"
 
+#include <boost/thread/locks.hpp>
+
 #include "CodePatterns/Observer/Notification.hpp"
 #include "CodePatterns/Observer/Observer.hpp"
@@ -30 +32 @@
 Notification::~Notification(){}
 
-void Notification::addObserver(Observer *target)
+void Notification::addObserver(Observer *target, const int priority)
 {
-  targets.insert(target);
+  boost::recursive_mutex::scoped_lock guard(TargetsLock);
+  targets.insert( std::make_pair(priority, target) );
 }
 
 void Notification::removeObserver(Observer *target)
 {
-  targets.erase(target);
+  boost::recursive_mutex::scoped_lock guard(TargetsLock);
+  for(targets_t::iterator iter=targets.begin();iter!=targets.end();) {
+    if((*iter).second == target) {
+      targets.erase(iter++);
+    } else {
+      ++iter;
+    }
+  }
 }
 
 void Notification::notifyAll(Observable * const publisher)
 {
-  for(std::set<Observer*>::iterator it=targets.begin();
-      it!=targets.end();++it){
+  boost::recursive_mutex::scoped_lock guard(TargetsLock);
+  // copy such that signOff() within receiving update() does not affect iterating
+  // this is because within the same thread and with the update() signOff() may be
+  // called and when executed it modifies targets
+  targets_t temp_targets = targets;
+  for(targets_t::iterator it=temp_targets.begin();
+      it!=temp_targets.end();++it){
 #ifdef LOG_OBSERVER
     observerLog().addMessage() << "-> Sending update from " << observerLog().getName(publisher)
                                << " for channel " << channelno
-                               << " to " << observerLog().getName(*it);
+                               << " to " << observerLog().getName((*it).second);
 #endif
-    (*it)->recieveNotification(publisher,this);
+    (*it).second->recieveNotification(publisher,this);
   }
 }
@@ -55 +70 @@
 void Notification::subjectKilled(Observable * const publisher)
 {
-  for(std::set<Observer*>::iterator it=targets.begin();
-      it!=targets.end();++it){
-    (*it)->subjectKilled(publisher);
+  boost::recursive_mutex::scoped_lock guard(TargetsLock);
+  // copy such that signOff() within receiving subjectKilled() does not affect iterating
+  // this is because within the same thread and with the subjectKilled() signOff() may be
+  // called and when executed it modifies targets
+  for(targets_t::iterator it=targets.begin();
+      !targets.empty();it=targets.begin()){
+    Observer *target = (*it).second;
+    const size_t prior_size = targets.size();
+    target->subjectKilled(publisher);
+    if (prior_size == targets.size())
+      targets.erase(it);
   }
 }