commit ce4fbe111da9375e9614e018547e90092df6ec4b
author Brad Bishop <bradleyb@fuzziesquirrel.com> Tue Jun 06 23:58:09 2017 -0400
committer Brad Bishop <bradleyb@fuzziesquirrel.com> Mon Jun 19 16:28:06 2017 -0400
tree dd81218e07476a9affd8adcf64bc66167b637f87
parent 18b228ee24bc6446292785cd1821d417a7c6a0c8

expose watch callbacks

Allow watch class users to explicitly invoke the watch
callback.

Since watches and callbacks share a common pool of state
all watches must complete their initialization prior to
invoking their callback methods.

Change-Id: I62ebad64da88a145f3d5006b07c01381b0eb6728
Signed-off-by: Brad Bishop <bradleyb@fuzziesquirrel.com>

src/propertywatch.hpp

diff --git a/src/propertywatch.hpp b/src/propertywatch.hpp
index 3eb05df..55f6e5b 100644
--- a/src/propertywatch.hpp
+++ b/src/propertywatch.hpp
@@ -37,8 +37,8 @@
         virtual ~PropertyWatch() = default;
         PropertyWatch(
             const PropertyIndex& watchIndex,
-            Callback* cb = nullptr)
-            : Watch(), index(watchIndex), callback(cb), alreadyRan(false) {}
+            Callback* callback = nullptr)
+            : Watch(), index(watchIndex), cb(callback), alreadyRan(false) {}
 
         /** @brief Start the watch.
          *
@@ -46,6 +46,12 @@
          */
         void start() override;
 
+        /** @brief Run the watch callback method.
+         *
+         *  Watch callback interface implementation for PropertyWatch.
+         */
+        void callback() override;
+
         /** @brief Update properties.
          *
          *  Subclasses to query the properties specified by the index
@@ -89,7 +95,7 @@
         const PropertyIndex& index;
 
         /** @brief Optional callback method. */
-        Callback* const callback;
+        Callback* const cb;
 
         /** @brief The start method should only be invoked once. */
         bool alreadyRan;

src/propertywatchimpl.hpp

diff --git a/src/propertywatchimpl.hpp b/src/propertywatchimpl.hpp
index d0153e4..67bbaff 100644
--- a/src/propertywatchimpl.hpp
+++ b/src/propertywatchimpl.hpp
@@ -108,6 +108,16 @@
     alreadyRan = true;
 }
 
+template <typename DBusInterfaceType>
+void PropertyWatch<DBusInterfaceType>::callback()
+{
+    // Invoke callback if present.
+    if (this->alreadyRan && this->cb)
+    {
+        (*this->cb)();
+    }
+}
+
 template <typename T, typename DBusInterfaceType>
 void PropertyWatchOfType<T, DBusInterfaceType>::updateProperties(
     const std::string& busName,
@@ -144,10 +154,7 @@
         std::get<2>(item->second).get() = p.second.template get<T>();
 
         // Invoke callback if present.
-        if (this->alreadyRan && this->callback)
-        {
-            (*this->callback)();
-        }
+        this->callback();
     }
 }
 

src/watch.hpp

diff --git a/src/watch.hpp b/src/watch.hpp
index 1ba671d..e36af9c 100644
--- a/src/watch.hpp
+++ b/src/watch.hpp
@@ -15,7 +15,10 @@
  *  or initialization.  Typical implementations might register dbus
  *  callbacks or perform queries.
  *
- *  Watches of any type can be started.
+ *  The callback method is invoked by main() on all watches of any
+ *  type at application startup, after all watches have performed
+ *  their setup.  Typical implementations will forward the call
+ *  to their associated callback.
  */
 class Watch
 {
@@ -29,6 +32,10 @@
 
         /** @brief Start the watch. */
         virtual void start() = 0;
+
+        /** @brief Invoke the callback associated with the watch. */
+        virtual void callback() = 0;
+
 };
 
 } // namespace monitoring