Changeset 74e0f7

Timestamp:

Sep 1, 2011, 11:07:47 AM (14 years ago)

Author:

Frederik Heber <heber@…>

Children:

9e776f

Parents:

451f17

git-author:

Frederik Heber <heber@…> (09/01/11 11:02:49)

git-committer:

Frederik Heber <heber@…> (09/01/11 11:07:47)

Message:

Extended Observables by NotificationChannels member variable.

• new class Channels that aggregates Notifications.
• NOTIFY now just takes a channel number.
• may or may not be instantiated for a given Observable.
• Observable just needs to add enum of all desired channels and addChannel on each of these.
• ObserverUnitTest has been adapted.

Location:

src/Patterns

Files:

• Observer.cpp (modified) (3 diffs)
• Observer.hpp (modified) (6 diffs)
• unittests/ObserverUnitTest.cpp (modified) (2 diffs)
• unittests/stubs/ObserverStub.cpp (modified) (3 diffs)
• unittests/stubs/ObserverStub.hpp (modified) (6 diffs)

src/Patterns/Observer.cpp

@@ -271 +271 @@
 }
 
+Notification_ptr Observable::getChannel(size_t no) const
+{
+  ASSERT(NotificationChannels != NULL,
+      "Observable::getChannel() - observable has no channels.");
+  return NotificationChannels->getChannel(no);
+}
+
 /** Handles sub-observables that just got killed
  *  when an sub-observerable dies we usually don't need to do anything
@@ -350 +357 @@
 
 Notification::Notification(Observable *_owner) :
-    owner(_owner)
+    owner(_owner), channelno(-1)
+{}
+
+Notification::Notification(Observable *_owner, size_t _channelno) :
+    owner(_owner), channelno(_channelno)
 {}
 
@@ -369 +380 @@
   }
 }
+
+Channels::Channels(Observable *_owner) :
+  owner(_owner)
+{}
+
+Channels::~Channels()
+{
+  // free all present Notifications
+  for(NotificationTypetoRefMap::iterator iter = ChannelMap.begin();
+      !ChannelMap.empty(); iter = ChannelMap.begin()) {
+    delete iter->second;
+    ChannelMap.erase(iter);
+  }
+}
+
+void Channels::addChannel(size_t no)
+{
+  NotificationTypetoRefMap::const_iterator iter = ChannelMap.find(no);
+  ASSERT(iter == ChannelMap.end(),
+      "Channels::addChannel() - channel "+toString(int(no))+" is already present in ChannelMap.");
+  ChannelMap.insert( std::make_pair(no, new Notification(owner, no)) );
+}
+
+void Channels::removeChannel(size_t no)
+{
+  NotificationTypetoRefMap::iterator iter = ChannelMap.find(no);
+  ASSERT(iter != ChannelMap.end(),
+      "Channels::removeChannel() - channel "+toString(int(no))+" not present in ChannelMap.");
+  delete iter->second;
+  ChannelMap.erase(iter);
+}
+
+Notification_ptr Channels::getChannel(size_t no) const
+{
+  NotificationTypetoRefMap::const_iterator iter = ChannelMap.find(no);
+  ASSERT(iter != ChannelMap.end(),
+      "Channels::getChannel() - channel "+toString(int(no))+" not present in ChannelMap.");
+  return iter->second;
+}
+
+size_t Channels::getType(Notification_ptr channel) const
+{
+  return channel->getChannelNo();
+}
+
 
 #ifdef LOG_OBSERVER

src/Patterns/Observer.hpp

@@ -40 +40 @@
 #endif
 
+class Channels;
+class Notification;
 class Observable;
-class Notification;
 
 // Pointers to notifications are used for unique identification
@@ -145 +146 @@
   virtual bool isBlocked();
 
+  Notification_ptr getChannel(size_t no) const;
+
 protected:
   virtual void update(Observable *publisher);
@@ -164 +167 @@
 
   static void enque_notification_internal(Observable *publisher, Notification_ptr notification);
+
+  Channels *NotificationChannels;
 
 private:
@@ -192 +197 @@
 };
 
+/** Notifications are sort of new channels of an Observable.
+ * Via the NOTIFY() macro updates can be transmitted in a specific channel.
+ * Observers can subscribe to Notification in much the same way as they can to
+ * the Observable itself. Usually, Notifications
+ */
 class Notification {
   friend class Observable;
+  friend class Channels;
 public:
   Notification(Observable *_owner);
+  Notification(Observable *_owner, size_t _channelno);
   virtual ~Notification();
+
+  size_t getChannelNo() const { return channelno; }
 protected:
 
@@ -206 +220 @@
   Observable * const owner;
   std::set<Observer*> targets;
+  size_t channelno;
+};
+
+/** Channels aggregate all possible Notifications of an Observable.
+ *
+ * Usually, one implements an enumeration of the channel number which is
+ * visible to the outside only.
+ *
+ */
+class Channels {
+public:
+  Channels(Observable *_owner);
+  virtual ~Channels();
+
+  void addChannel(size_t no);
+
+  Notification_ptr getChannel(size_t no) const;
+  size_t getType(Notification_ptr channel) const;
+
+protected:
+  void removeChannel(size_t no);
+
+private:
+  Observable * const owner;
+
+  typedef std::map< size_t, Notification_ptr> NotificationTypetoRefMap;
+
+  NotificationTypetoRefMap ChannelMap;
 };
 
@@ -245 +287 @@
 #define PASTE_HELPER(a,b) a ## b
 #define OBSERVE Observable::_Observable_protector PASTE(_scope_obs_protector_,__LINE__)(this)
-#define NOTIFY(notification) do{Observable::enque_notification_internal(this,notification);}while(0)
+#define NOTIFY(channelno) do{Observable::enque_notification_internal(this,NotificationChannels->getChannel(channelno));}while(0)
 #define LOCK_OBSERVABLE(observable) Observable::_Observable_protector PASTE(_scope_obs_protector_,__LINE__)(&(observable))
 

src/Patterns/unittests/ObserverUnitTest.cpp

@@ -61 +61 @@
   observer4 = new UpdateCountObserver();
 
-  notificationObserver1 = new NotificationObserver(notificationObservable->notification1);
-  notificationObserver2 = new NotificationObserver(notificationObservable->notification2);
+  notificationObserver1 = new NotificationObserver(
+      notificationObservable->getChannel(NotificationObservable::Operation1Notify));
+  notificationObserver2 = new NotificationObserver(
+      notificationObservable->getChannel(NotificationObservable::Operation2Notify));
 }
 
@@ -157 +159 @@
 
 void ObserverTest::doesNotifyTest(){
+  CPPUNIT_ASSERT_EQUAL(
+      (size_t)NotificationObservable::Operation1Notify,
+      notificationObservable->getChannel(NotificationObservable::Operation1Notify)->getChannelNo());
+  CPPUNIT_ASSERT_EQUAL(
+      (size_t)NotificationObservable::Operation2Notify,
+      notificationObservable->getChannel(NotificationObservable::Operation2Notify)->getChannelNo());
   notificationObservable->signOn(notificationObserver1,
-                                 notificationObservable->notification1);
+                                 notificationObservable->getChannel(NotificationObservable::Operation1Notify));
   notificationObservable->signOn(notificationObserver2,
-                                 notificationObservable->notification2);
+                                 notificationObservable->getChannel(NotificationObservable::Operation2Notify));
 
   notificationObservable->operation1();

src/Patterns/unittests/stubs/ObserverStub.cpp

@@ -31 +31 @@
 {};
 
+UpdateCountObserver::~UpdateCountObserver()
+{}
+
 void UpdateCountObserver::update(Observable *publisher){
   updates++;
@@ -127 +130 @@
 
 NotificationObservable::NotificationObservable() :
-  Observable("NotificationObservable"),
-  notification1(new Notification(this)),
-  notification2(new Notification(this))
-{}
-
-NotificationObservable::~NotificationObservable(){
-  delete notification1;
-  delete notification2;
+  Observable("NotificationObservable")
+{
+  NotificationChannels = new Channels(this);
+  NotificationChannels->addChannel(Operation1Notify);
+  NotificationChannels->addChannel(Operation2Notify);
+}
+
+NotificationObservable::~NotificationObservable()
+{
+  delete NotificationChannels;
 }
 
 void NotificationObservable::operation1(){
   OBSERVE;
-  NOTIFY(notification1);
+  NOTIFY(Operation1Notify);
 }
 
 void NotificationObservable::operation2(){
   OBSERVE;
-  NOTIFY(notification2);
+  NOTIFY(Operation2Notify);
 }
 
@@ -153 +158 @@
   requestedNotification(notification),
   wasNotified(false)
+{}
+
+NotificationObserver::~NotificationObserver()
 {}
 

src/Patterns/unittests/stubs/ObserverStub.hpp

@@ -15 +15 @@
 public:
   UpdateCountObserver();
+  virtual ~UpdateCountObserver();
+
   void update(Observable *publisher);
   void subjectKilled(Observable *publisher);
@@ -52 +54 @@
 public:
   SuperObservable();
-  ~SuperObservable();
+  virtual ~SuperObservable();
 
   void changeMethod();
@@ -62 +64 @@
 public:
   NotificationObservable();
-  ~NotificationObservable();
+  virtual ~NotificationObservable();
+
+  enum NotificationType {
+    Operation1Notify = 0,
+    Operation2Notify = 1
+  };
 
   void operation1();
   void operation2();
-
-  Notification_ptr notification1;
-  Notification_ptr notification2;
 };
 
@@ -74 +78 @@
 public:
   NotificationObserver(Notification_ptr notification);
+  virtual ~NotificationObserver();
 
   void update(Observable*);
@@ -91 +96 @@
 
   ObservableSet(int _num);
-  ~ObservableSet();
+  virtual ~ObservableSet();
 
   iterator begin();
@@ -109 +114 @@
 
   ObservableMap(int _num);
-  ~ObservableMap();
+  virtual ~ObservableMap();
 
   iterator begin();