Changeset 454bc54 for src/CodePatterns

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.

Location:

src/CodePatterns

Files:

• Cacheable.hpp (modified) (10 diffs)
• ObservedValue.hpp (added)
• Observer/Notification.hpp (modified) (3 diffs)
• Observer/Observable.hpp (modified) (3 diffs)
• Observer/Relay.hpp (modified) (1 diff)

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");

src/CodePatterns/Observer/Notification.hpp

@@ -15 +15 @@
 
 #include <set>
+
+#include <boost/thread/recursive_mutex.hpp>
 
 class Channels;
@@ -41 +43 @@
 protected:
 
-  void addObserver(Observer *target);
+  void addObserver(Observer *target, const int priority);
   void removeObserver(Observer *target);
 
@@ -73 +75 @@
 
 private:
-  typedef std::set<Observer*> targets_t;
+  typedef std::multimap<int,Observer*> targets_t;
   targets_t targets;
   const size_t channelno;
+
+  mutable boost::recursive_mutex TargetsLock; //!< a lock for the pointer of the instance
 };
 

src/CodePatterns/Observer/Observable.hpp

@@ -45 +45 @@
 class Observable : public Observer {
 public:
-  Observable(std::string _name);
+  //!> typedef for a vector of channels
+  typedef std::vector<size_t> channels_t;
+
+  Observable(std::string _name, const channels_t &_channels = channels_t());
   virtual ~Observable();
 
@@ -63 +66 @@
     static range<int> ValidRange;
   };
+
+private:
+  /** Helper class to create a unique increasing list.
+   *
+   */
+  struct UniqueNumber
+  {
+    int operator()()
+    { return value++; }
+    int value;
+  };
+
+public:
+  static channels_t getChannelList(const size_t max);
 
   /**
@@ -86 +103 @@
    * Sign on for specialized notifications
    */
-  virtual void signOn(Observer *target, size_t channelno) const;
+  virtual void signOn(
+      Observer *target,
+      size_t channelno,
+      PriorityLevel priority = PriorityDefault) const;
 
   /**

src/CodePatterns/Observer/Relay.hpp

@@ -40 +40 @@
   virtual void signOff(Observer *target) const;
 
-  virtual void signOn(Observer *target, size_t channelno) const;
+  virtual void signOn(Observer *target, size_t channelno, PriorityLevel priority = Observable::PriorityDefault) const;
 
   virtual void signOff(Observer *target, size_t channelno) const;