Fixed watchers that could be added twice to the same definition node

src/definition/DefinitionNode.cpp

@@ -181,6 +181,18 @@ void DefinitionNode::addWatcher(DefinitionWatcher *watcher, bool init_diff)
     }
 }
 
+int DefinitionNode::getWatcherCount() const
+{
+    if (root && root->diffs)
+    {
+        return root->diffs->getWatcherCount(this);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
 void DefinitionNode::save(PackStream* stream) const
 {
     int children_count = (int)children.size();

src/definition/DefinitionNode.h

@@ -77,6 +77,11 @@ public:
      */
     void addWatcher(DefinitionWatcher *watcher, bool init_diff=false);
 
+    /**
+     * Get the current number of watchers.
+     */
+    int getWatcherCount() const;
+
 protected:
     void addChild(DefinitionNode* child);
     void removeChild(DefinitionNode* child);

src/definition/DiffManager.cpp

@@ -21,7 +21,15 @@ DiffManager::~DiffManager()
 
 void DiffManager::addWatcher(const DefinitionNode *node, DefinitionWatcher *watcher)
 {
-    watchers[node].push_back(watcher);
+    if (std::find(watchers[node].begin(), watchers[node].end(), watcher) == watchers[node].end())
+    {
+        watchers[node].push_back(watcher);
+    }
+}
+
+int DiffManager::getWatcherCount(const DefinitionNode *node)
+{
+    return watchers[node].size();
 }
 
 void DiffManager::addDiff(DefinitionNode *node, const DefinitionDiff *diff)

src/definition/DiffManager.h

@@ -27,6 +27,11 @@ public:
      */
     void addWatcher(const DefinitionNode *node, DefinitionWatcher *watcher);
 
+    /**
+     * Get the number of watchers registered for a given node.
+     */
+    int getWatcherCount(const DefinitionNode *node);
+
     /**
      * Add a new diff of a node to the change flow.
      */

src/tests/DefinitionNode_Test.cpp

@@ -3,6 +3,7 @@
 #include "DefinitionNode.h"
 #include "FloatNode.h"
 #include "PackStream.h"
+#include "DefinitionWatcher.h"
 
 TEST(DefinitionNode, toString)
 {
@@ -26,6 +27,25 @@ TEST(DefinitionNode, getPath)
     EXPECT_EQ("/branch/leaf", leaf.getPath());
 }
 
+class FakeWatcher: public DefinitionWatcher
+{
+    virtual void nodeChanged(const DefinitionNode *, const DefinitionDiff *) override
+    {
+    }
+};
+
+TEST(DefinitionNode, addWatcher)
+{
+    DefinitionNode root(NULL, "root");
+    FakeWatcher watcher;
+
+    EXPECT_EQ(0, root.getWatcherCount());
+    root.addWatcher(&watcher);
+    EXPECT_EQ(1, root.getWatcherCount());
+    root.addWatcher(&watcher);
+    EXPECT_EQ(1, root.getWatcherCount());
+}
+
 TEST(DefinitionNode, findByPath)
 {
     DefinitionNode root(NULL, "root");