Changeset 1c291d for src/CodePatterns/Observer

Timestamp:

Mar 18, 2013, 6:29:41 PM (13 years ago)

Author:

Frederik Heber <heber@…>

Children:

3f30cc

Parents:

b9273a

git-author:

Frederik Heber <heber@…> (03/18/13 18:22:47)

git-committer:

Frederik Heber <heber@…> (03/18/13 18:29:41)

Message:

Channels and Notifications pass on subjectKilled().

• if we only sign on to a single notification channel, we miss on subjectKilled() completely. Hence, we have to chance of properly signing off again or, at least, to know that we must not anymore.
• Hence, Observable's dstor now calls subjectKilled() on its Channels which passes the call on to all its Notifications that in turn use the subjectKilled() slot of their targets along with the passed-through Observable instance.
• also added observerLog verbosity when signing on/off to channels.
• explained this in header documentation of Observable, Channels, and Notification.
• TESTFIX: ObserverUnitTest did not properly signOff() before deleting instances in relayNotificationTest().

Location:

src/CodePatterns/Observer

Files:

• Channels.hpp (modified) (3 diffs)
• Notification.hpp (modified) (3 diffs)
• Observable.hpp (modified) (1 diff)

src/CodePatterns/Observer/Channels.hpp

@@ -18 +18 @@
 #include "CodePatterns/Observer/defs.hpp"
 
+class Observable;
+class Relay;
+
 /** Channels aggregate all possible Notifications of an Observable.
  *
@@ -23 +26 @@
  * visible to the outside only.
  *
+ * \note Channels::subjectKilled() needs to be called by owning Observable.
+ * It is passed on to Notification such that Observer that have only signed
+ * on to single channel still know when their observable has died.
  */
 class Channels {
@@ -38 +44 @@
 
 private:
+  //! grant Observable access to notifyAll() and subjectKilled()
+  friend class Observable;
+  //!> grant Relay access to notifyAll()
+  friend class Relay;
+
+  /** Informs channel subscribers about imminent dstor call.
+   *
+   * This is meant to be called from Observable only.
+   * Channels and Notifications are strictly attached to an Observable. Hence,
+   * it makes no sense to inform them on their own. Especially, neither has
+   * any knowledge on the publisher.
+   *
+   * \param *publisher Observable about to be destroyed
+   */
+  void subjectKilled(Observable * const publisher);
+
+private:
   typedef std::map< size_t, Notification_ptr> NotificationTypetoRefMap;
 

src/CodePatterns/Observer/Notification.hpp

@@ -16 +16 @@
 #include <set>
 
+class Channels;
 class Observable;
 class Observer;
@@ -26 +27 @@
  * with the usual OBSERVE() macro to generate both the specific and
  * the global message of change.
+ *
+ * \note Notification::subjectKilled() needs to be called by owning Channels.
+ * We use the passed on Observable instance to let Observers that have only 
+ * signed on to single channel know when their observable has died.
  */
 class Notification {
-  //!> grant Observable access to notifyAll()
-  friend class Observable;
-  //!> grant Relay access to notifyAll()
-  friend class Relay;
 public:
   Notification(size_t _channelno);
@@ -43 +44 @@
   void removeObserver(Observer *target);
 
+private:
+  //!> grant Observable access to notifyAll() and subjectKilled()
+  friend class Observable;
+  //!> grant Channels access to notifyAll() and subjectKilled()
+  friend class Channels;
+  //!> grant Relay access to notifyAll()
+  friend class Relay;
+
   void notifyAll(Observable * const publisher);
+
+  /** Informs channel subscribers about dstor call.
+   *
+   * This is meant to be called from Observable only.
+   * Channels and Notifications are strictly attached to an Observable. Hence,
+   * it makes no sense to inform them on their own. Especially, neither has
+   * any knowledge on the publisher.
+   *
+   * \param *publisher Observable about to be destroyed
+   */
+  void subjectKilled(Observable * const publisher);
+
 private:
-  std::set<Observer*> targets;
+  typedef std::set<Observer*> targets_t;
+  targets_t targets;
   const size_t channelno;
 };

src/CodePatterns/Observer/Observable.hpp

@@ -30 +30 @@
  * to avoid memory issues when many observable are around but only few
  * are actually observed.
+ *
+ * \note We have to clean our Channels from static NotificationChannels and
+ * we call Channels::subjectKilled() to let Observers that have only signed
+ * on to single channel still know when their observable has died.
  */
 class Observable : public Observer {