Implement notification loop safeguard in ofParameter<void>

libs/openFrameworks/types/ofParameter.cpp

@@ -106,50 +106,70 @@ ofParameter<void>& ofParameter<void>::set(const std::string & name){
 }
 
 void ofParameter<void>::trigger(){
-	ofNotifyEvent(obj->changedE,this);
-    // Notify all parents, if there are any.
-    if(!obj->parents.empty())
+    // If the object is notifying its parents, just set the value without triggering an event.
+    if(!obj->bInNotify)
     {
-        // Erase each invalid parent
-        obj->parents.erase(std::remove_if(obj->parents.begin(),
-                                          obj->parents.end(),
-                                          [](const std::weak_ptr<ofParameterGroup::Value> & p){ return p.expired(); }),
-                           obj->parents.end());
-
-        // notify all leftover (valid) parents of this object's changed value.
-        // this can't happen in the same iterator as above, because a notified listener
-        // might perform similar cleanups that would corrupt our iterator
-        // (which appens for example if the listener calls getFirstParent on us)
-        for(auto & parent: obj->parents){
-            auto p = parent.lock();
-            if(p){
-                p->notifyParameterChanged(*this);
+        // Mark the object as in its notification loop.
+        obj->bInNotify = true;
+
+        // Notify any local subscribers.
+        ofNotifyEvent(obj->changedE, this);
+
+        // Notify all parents, if there are any.
+        if(!obj->parents.empty())
+        {
+            // Erase each invalid parent
+            obj->parents.erase(std::remove_if(obj->parents.begin(),
+                                              obj->parents.end(),
+                                              [this](const std::weak_ptr<ofParameterGroup::Value> & p){ return p.expired(); }),
+                               obj->parents.end());
+
+            // notify all leftover (valid) parents of this object's changed value.
+            // this can't happen in the same iterator as above, because a notified listener
+            // might perform similar cleanups that would corrupt our iterator
+            // (which appens for example if the listener calls getFirstParent on us)
+            for(auto & parent: obj->parents){
+                auto p = parent.lock();
+                if(p){
+                    p->notifyParameterChanged(*this);
+                }
             }
         }
+        obj->bInNotify = false;
     }
 }
 
 void ofParameter<void>::trigger(const void * sender){
-	ofNotifyEvent(obj->changedE,sender);
-    // Notify all parents, if there are any.
-    if(!obj->parents.empty())
+	// If the object is notifying its parents, Do not trigger the event.
+    if(!obj->bInNotify)
     {
-        // Erase each invalid parent
-        obj->parents.erase(std::remove_if(obj->parents.begin(),
-                                          obj->parents.end(),
-                                          [](const std::weak_ptr<ofParameterGroup::Value> & p){ return p.expired(); }),
-                           obj->parents.end());
-
-        // notify all leftover (valid) parents of this object's changed value.
-        // this can't happen in the same iterator as above, because a notified listener
-        // might perform similar cleanups that would corrupt our iterator
-        // (which appens for example if the listener calls getFirstParent on us)
-        for(auto & parent: obj->parents){
-            auto p = parent.lock();
-            if(p){
-                p->notifyParameterChanged(*this);
+        // Mark the object as in its notification loop.
+        obj->bInNotify = true;
+
+        // Notify any local subscribers.
+        ofNotifyEvent(obj->changedE, this);
+
+        // Notify all parents, if there are any.
+        if(!obj->parents.empty())
+        {
+            // Erase each invalid parent
+            obj->parents.erase(std::remove_if(obj->parents.begin(),
+                                              obj->parents.end(),
+                                              [this](const std::weak_ptr<ofParameterGroup::Value> & p){ return p.expired(); }),
+                               obj->parents.end());
+
+            // notify all leftover (valid) parents of this object's changed value.
+            // this can't happen in the same iterator as above, because a notified listener
+            // might perform similar cleanups that would corrupt our iterator
+            // (which appens for example if the listener calls getFirstParent on us)
+            for(auto & parent: obj->parents){
+                auto p = parent.lock();
+                if(p){
+                    p->notifyParameterChanged(*this);
+                }
             }
         }
+        obj->bInNotify = false;
     }
 }
 

libs/openFrameworks/types/ofParameter.h

@@ -1054,14 +1054,17 @@ class ofParameter<void>: public ofAbstractParameter{
 	class Value{
 	public:
 		Value()
-		:serializable(false){}
+		:bInNotify(false)
+        ,serializable(false){}
 
 		Value(std::string name)
 		:name(name)
+        ,bInNotify(false)
 		,serializable(false){}
 
 		std::string name;
 		ofEvent<void> changedE;
+        bool bInNotify;
 		bool serializable;
 		std::vector<std::weak_ptr<ofParameterGroup::Value>> parents;
 	};