Changeset b760ac5

Timestamp:

Dec 13, 2011, 12:02:21 PM (14 years ago)

Author:

Frederik Heber <heber@…>

Children:

3324cf

Parents:

d85532

git-author:

Frederik Heber <heber@…> (12/02/11 13:13:44)

git-committer:

Frederik Heber <heber@…> (12/13/11 12:02:21)

Message:

Relay can now also relay notifications.

• NOTE: We do not yet notify the Observables, whose update() we combine, when the Relay is destroyed. They have to signOff before by themselves (or by some other means, e.g. be destroyed before.).

Location:

src

Files:

• Patterns/Observer/Relay.cpp (modified) (4 diffs)
• Patterns/Observer/Relay.hpp (modified) (2 diffs)
• Patterns/Observer/unittests/ObserverUnitTest.cpp (modified) (3 diffs)
• Patterns/Observer/unittests/ObserverUnitTest.hpp (modified) (4 diffs)
• Patterns/Observer/unittests/stubs/ObserverStub.cpp (modified) (2 diffs)
• Patterns/Observer/unittests/stubs/ObserverStub.hpp (modified) (1 diff)
• documentation/patterns/observer.dox (modified) (1 diff)

src/Patterns/Observer/Relay.cpp

@@ -24 +24 @@
 #include "Assert.hpp"
 #include "Channels.hpp"
-#include "defs.hpp"
 #include "Notification.hpp"
 
@@ -48 +47 @@
   observerLog().addMessage() << "-- Destroying Relay " << observerLog().getName(this);
 #endif
-}
-
+  // killing subjects is done by Observables' dstor
+}
+
+
+
+/** Sign on an Observer to this Observable.
+ * Puts \a *target into Observable::callTable list.
+ * \param *target Observer
+ * \param priority number in [-20,20]
+ */
+void Relay::signOn(Observer *target, PriorityLevel priority) const
+{
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "@@ Signing on " << observerLog().getName(target)
+      << " to "
+      << observerLog().getName(const_cast<Observable *>(static_cast<const Observable * const>(this)));
+#endif
+  bool res = false;
+  callees_t &callees = callTable[const_cast<Observable *>(static_cast<const Observable * const>(this))];
+
+  callees_t::iterator iter;
+  for(iter=callees.begin();iter!=callees.end();++iter){
+    res |= ((*iter).second == target);
+  }
+  if(!res)
+    callees.insert(std::pair<int,Observer*>(priority.level,target));
+}
+
+/** Sign off an Observer from this Observable.
+ * Removes \a *target from Observable::callTable list.
+ * \param *target Observer
+ */
+void Relay::signOff(Observer *target) const
+{
+  ASSERT(callTable.count(const_cast<Observable *>(static_cast<const Observable * const>(this))),
+      "Relay::signOff() - called for an Observable without Observers.");
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "** Signing off " << observerLog().getName(target)
+      << " from "
+      << observerLog().getName(const_cast<Observable *>(static_cast<const Observable * const>(this)));
+#endif
+  callees_t &callees = callTable[const_cast<Observable *>(static_cast<const Observable * const>(this))];
+
+  callees_t::iterator iter;
+  callees_t::iterator deliter;
+  for(iter=callees.begin();iter!=callees.end();) {
+    if((*iter).second == target) {
+      callees.erase(iter++);
+    }
+    else {
+      ++iter;
+    }
+  }
+  if(callees.empty()){
+    callTable.erase(const_cast<Observable *>(static_cast<const Observable * const>(this)));
+  }
+}
+
+void Relay::signOn(Observer *target, size_t channelno) const
+{
+  Notification_ptr notification = getChannel(channelno);
+  notification->addObserver(target);
+}
+
+void Relay::signOff(Observer *target, size_t channelno) const
+{
+  Notification_ptr notification = getChannel(channelno);
+  notification->removeObserver(target);
+}
 
 /** Notify all Observers of changes.
@@ -125 +191 @@
       Updater = publisher;
       notifyAll();
+      Updater = NULL;
     }
     else{
@@ -135 +202 @@
 }
 
-//Notification_ptr Relay::getChannel(size_t no) const
-//{
-//  ASSERT(NotificationChannels != NULL,
-//      "Relay::getChannel() - observable has no channels.");
-//  return NotificationChannels->getChannel(no);
-//}
+/** Method for receiving specialized notifications.
+ *
+ * \param *publisher The \a *this we observe.
+ * \param notification type of notification
+ */
+void Relay::recieveNotification(Observable *publisher, Notification_ptr notification)
+{
+  Updater = publisher;
+  const Channels *myChannels = NotificationChannels[const_cast<Observable *>(static_cast<const Observable * const>(this))];
+  ASSERT(myChannels != NULL,
+      "Relay::recieveNotification() - this relay does not have any channels.");
+  const size_t channelno = notification->getChannelNo();
+  Notification_ptr mynotification = myChannels->getChannel(channelno);
+  ASSERT(mynotification != NULL,
+      "Relay::recieveNotification() - this relay does not have a notification no "+toString(channelno)+".");
+  mynotification->notifyAll(Updater);
+  Updater = NULL;
+}
 
 /** Handles sub-observables that just got killed

src/Patterns/Observer/Relay.hpp

@@ -36 +36 @@
   virtual ~Relay();
 
-//  Notification_ptr getChannel(size_t no) const;
+  virtual void signOn(Observer *target, PriorityLevel priority = Observable::PriorityDefault) const;
+
+  virtual void signOff(Observer *target) const;
+
+  virtual void signOn(Observer *target, size_t channelno) const;
+
+  virtual void signOff(Observer *target, size_t channelno) const;
 
 protected:
   virtual void update(Observable *publisher);
+  virtual void recieveNotification(Observable *publisher, Notification_ptr notification);
   virtual void subjectKilled(Observable *publisher);
 
@@ -47 +54 @@
   //!> Current peer that called last update on us, to be passed on to Observers
   Observable *Updater;
-//protected:
-//
-//  Channels *NotificationChannels;
-//
 };
 

src/Patterns/Observer/unittests/ObserverUnitTest.cpp

@@ -71 +71 @@
   RelayObservable = new RelayTest;
   RelayObserver = new RelayCountObserver(RelayObservable);
+
+  RelayNotifier = new RelayNotification;
+  RelayNotified = new RelayNotificationObserver(RelayObservable);
 }
 
@@ -84 +87 @@
   delete RelayObservable;
   delete RelayObserver;
+  delete RelayNotifier;
+  delete RelayNotified;
 
   delete observer1;
@@ -276 +281 @@
 }
 
+void ObserverTest::relayNotificationTest()
+{
+  observerLog().enableLogging();
+
+  // sign on some observables to the relay
+  notificationObservable->signOn(RelayNotifier, NotificationObservable::Operation1Notify);
+  notificationObservable->signOn(RelayNotifier, NotificationObservable::Operation2Notify);
+  notificationObservable->signOn(notificationObserver1, NotificationObservable::Operation1Notify);
+
+  RelayNotifier->signOn(RelayNotified, NotificationObservable::Operation1Notify);
+
+  // operation1
+  notificationObservable->operation1();
+  CPPUNIT_ASSERT(RelayNotified->wasNotified);
+  CPPUNIT_ASSERT(notificationObserver1->wasNotified);
+
+  RelayNotified->wasNotified=false;
+
+  // operation2
+  notificationObservable->operation2();
+  CPPUNIT_ASSERT(!RelayNotified->wasNotified);
+  CPPUNIT_ASSERT(notificationObserver1->wasNotified);
+
+  // signOff relay from 1 and operation1
+  notificationObserver1->wasNotified=false;
+  notificationObservable->signOff(RelayNotifier, NotificationObservable::Operation1Notify);
+
+  notificationObservable->operation1();
+  CPPUNIT_ASSERT(!RelayNotified->wasNotified);
+  CPPUNIT_ASSERT(notificationObserver1->wasNotified);
+
+  // test kill subject
+  delete RelayNotified;
+  RelayNotified = NULL; // delete in tearDown is allowed for NULL
+  notificationObservable->operation1();
+  delete notificationObservable;
+  notificationObservable = NULL; // delete in tearDown is allowed for NULL
+
+  observerLog().disableLogging();
+}
+
 void ObserverTest::CircleDetectionTest() {
   std::cout << std::endl << "Warning: the next test involved methods that can produce infinite loops." << std::endl;

src/Patterns/Observer/unittests/ObserverUnitTest.hpp

@@ -28 +28 @@
 class NotificationObservable;
 class RelayCountObserver;
+class RelayNotification;
+class RelayNotificationObserver;
 
 class ObserverTest :  public CppUnit::TestFixture
@@ -40 +42 @@
   CPPUNIT_TEST ( iteratorTest );
   CPPUNIT_TEST ( relayTest );
+  CPPUNIT_TEST ( relayNotificationTest );
   CPPUNIT_TEST ( CircleDetectionTest );
   CPPUNIT_TEST_SUITE_END();
@@ -55 +58 @@
   void iteratorTest();
   void relayTest();
+  void relayNotificationTest();
   void CircleDetectionTest();
 
@@ -76 +80 @@
   RelayTest *RelayObservable;
   RelayCountObserver *RelayObserver;
+  RelayNotification *RelayNotifier;
+  RelayNotificationObserver *RelayNotified;
 };
 

src/Patterns/Observer/unittests/stubs/ObserverStub.cpp

@@ -239 +239 @@
 {}
 
+/************ RelayNotification ***************/
+
+RelayNotification::RelayNotification() :
+    Relay(std::string("RelayTest"))
+{
+  Channels *OurChannel = new Channels();
+  NotificationChannels.insert( std::make_pair(this, OurChannel) );
+  OurChannel->addChannel(NotificationObservable::Operation1Notify);
+  OurChannel->addChannel(NotificationObservable::Operation2Notify);
+}
+
+RelayNotification::~RelayNotification()
+{}
+
 /************ RelayCountObserver ***************/
 
@@ -259 +273 @@
 }
 
+/********* RelayNotificationObserver ***********/
+
+RelayNotificationObserver::RelayNotificationObserver(const Observable * const _relay) :
+  Observer("RelayNotificationObserver"),
+  wasNotified(false),
+  relay(_relay)
+{}
+
+RelayNotificationObserver::~RelayNotificationObserver()
+{}
+
+void RelayNotificationObserver::update(Observable*){}
+void RelayNotificationObserver::subjectKilled(Observable*){}
+void RelayNotificationObserver::recieveNotification(Observable *publisher, Notification_ptr notification){
+  // check that we are not called by the relay itself
+  CPPUNIT_ASSERT(publisher != relay);
+  wasNotified = true;
+}
+

src/Patterns/Observer/unittests/stubs/ObserverStub.hpp

@@ -148 +148 @@
 };
 
+class RelayNotification : public Relay
+{
+public:
+  RelayNotification();
+  ~RelayNotification();
+private:
+};
+
+class RelayNotificationObserver : public Observer {
+public:
+  RelayNotificationObserver(const Observable * const _relay);
+  virtual ~RelayNotificationObserver();
+
+  void update(Observable*);
+  void subjectKilled(Observable*);
+  void recieveNotification(Observable *publisher, Notification_ptr notification);
+
+  bool wasNotified;
+private:
+  const Observable * const relay;
+};
+
 #endif /* OBSERVERSTUB_HPP_ */

src/documentation/patterns/observer.dox

@@ -28 +28 @@
  * updating many of its internal sub-observables. This means the update is not passed, if
  * it is produced while the main-observable itself is within any Observation block.
+ *
+ * \section pattern-observer-howtos Howto
+ *
+ *  Below you find various howtos to guide you through how to use the various
+ *  observer patterns.
+ *
+ * \section pattern-observer-howtos-observer Observers
+ *
+ *  \todo write howto for using an Observer
+ *
+ * \section pattern-observer-howtos-observables Observables
+ *
+ *  \todo write howto for using an Observable
+ *
+ * \section pattern-observer-howtos-relay Relays
+ *
+ *  Lets us assume that you want to observe all instances of class "foo".
+ *  In order to create a Relay you have to do the following:
+ *  -# Create a new class "bar" that inherits the Relay pattern.
+ *  \code
+ *    #include "CodePatterns/Relay.hpp"
+ *    class bar : public Relay {
+ *    ...
+ *    };
+ *  \endcode
+ *  -# In the constructor bar::bar() create a Channels object for your Relay and
+ *     add a channel for each of foo's channels, use foo's enum for this:
+ *   \code
+ *     bar::bar() {
+ *      Channels *OurChannel = new Channels();
+ *      NotificationChannels.insert( std::make_pair(this, OurChannel) );
+ *      OurChannel->addChannel(foo::Notification1);
+ *      OurChannel->addChannel(foo::Notification2);
+ *      ...
+ *     }
+ *   \endcode
+ *   -# Someplace else you have add all Observers that need to check on all
+ *      instances of "foo" to be signed on.
+ *    \code
+ *    bar barInstance;
+ *    ... someObserverInstance;
+ *    barInstance.signOn(someObserverInstance);
+ *    \endcode
+ *   -# ... or maybe just for a specific channel of foo.
+ *    \code
+ *    bar barInstance;
+ *    ... someObserverInstance;
+ *    barInstance.signOn(someObserverInstance, foo::Notification1);
+ *    \endcode
+ *
+ *
+ * \date 2011-12-01
  */