Changeset 454bc54 for src/CodePatterns/Cacheable.hpp

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/CodePatterns/Cacheable.hpp (modified) (10 diffs)

src/CodePatterns/Cacheable.hpp

@@ -20 +20 @@
 
 #include "CodePatterns/Assert.hpp"
+
+#include "CodePatterns/Observer/Notification.hpp"
 
 #ifndef NO_CACHING
@@ -142 +144 @@
 
   public:
-    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name);
+    Cacheable(
+        Observable *_owner,
+        const boost::function<T()> _recalcMethod,
+        const std::string &name,
+        const Observable::channels_t &_channels = Observable::channels_t());
     virtual ~Cacheable();
 
@@ -150 +156 @@
     // methods implemented for base-class Observer
     void update(Observable *subject);
+    void recieveNotification(Observable *publisher, Notification_ptr notification);
     void subjectKilled(Observable *subject);
   private:
@@ -160 +167 @@
     // destroyed state is not predefined, because we rarely enter that state and never leave
 
-    Observable *owner;
-    boost::function<T()> recalcMethod;
+    const Observable * owner;
+    const boost::function<T()> recalcMethod;
+
+    //!> contains list of possible channels to enlist, if empty we signOn globally
+    const Observable::channels_t channels;
 
     // de-activated copy constructor
@@ -169 +179 @@
 
   template<typename T>
-  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name) :
-    Observer(name + "(Cached)"),
+  Cacheable<T>::Cacheable(
+      Observable *_owner,
+      const boost::function<T()> _recalcMethod,
+      const std::string &_name,
+      const Observable::channels_t &_channels) :
+    Observer(_name + "(Cached)"),
     owner(_owner),
-    recalcMethod(_recalcMethod)
+    recalcMethod(_recalcMethod),
+    channels(_channels)
   {
     // create all states needed for this object
@@ -180 +195 @@
     // we sign on with the best(=lowest) priority, so cached values are recalculated before
     // anybody else might ask for updated values
-    if (owner != NULL)
-      owner->signOn(this,Observable::PriorityLevel(int(-20)));
+    if (owner != NULL) {
+      if (channels.empty()) {
+        owner->signOn(this,Observable::PriorityLevel(int(-20)));
+      } else {
+        for (Observable::channels_t::const_iterator iter = channels.begin();
+            iter != channels.end(); ++iter)
+          owner->signOn(this,*iter,Observable::PriorityLevel(int(-20)));
+      }
+    }
   }
 
@@ -204 +226 @@
   Cacheable<T>::~Cacheable()
   {
-    if (owner != NULL)
-      owner->signOff(this);
+    if (owner != NULL) {
+      if (channels.empty()) {
+        owner->signOff(this);
+      } else {
+        for (Observable::channels_t::const_iterator iter = channels.begin();
+            iter != channels.end(); ++iter)
+          owner->signOff(this,*iter);
+      }
+    }
   }
 
@@ -215 +244 @@
   template<typename T>
   void Cacheable<T>::update(Observable *subject) {
+    ASSERT( channels.empty(),
+        "Cacheable<T>::update() - we are listening only to global updates.");
     state->invalidate();
+  }
+
+  template<typename T>
+  void Cacheable<T>::recieveNotification(Observable *publisher, Notification_ptr notification) {
+    if (publisher == owner) {
+      ASSERT( !channels.empty(),
+          "Cacheable<T>::update() - we are not listening to global updates.");
+      const Observable::channels_t::const_iterator iter = std::find(
+          channels.begin(), channels.end(), notification->getChannelNo());
+      if (iter != channels.end())
+        state->invalidate();
+    }
   }
 
@@ -248 +291 @@
     // methods implemented for base-class Observer
     void update(Observable *subject);
+    void recieveNotification(Observable *publisher, Notification_ptr notification);
     void subjectKilled(Observable *subject);
   private:
@@ -280 +324 @@
 
   template<typename T>
+  void Cacheable<T>::recieveNotification(Observable *publisher, Notification_ptr notification) {
+    ASSERT(0, "Cacheable::recieveNotification should never be called when caching is disabled");
+  }
+
+  template<typename T>
   void Cacheable<T>::subjectKilled(Observable *subject){
     ASSERT(0, "Cacheable::subjectKilled should never be called when caching is disabled");