IpObserver.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IPOBSERVER_HPP__
#define __IPOBSERVER_HPP__
 
#include "IpUtils.hpp"
#include <vector>
#include <algorithm>
 
//#define IP_DEBUG_OBSERVER
#if IPOPT_CHECKLEVEL > 2
# define IP_DEBUG_OBSERVER
#endif
#ifdef IP_DEBUG_OBSERVER
# include "IpDebug.hpp"
#endif
 
namespace Ipopt
{
/* Forward declaration */
class Subject;
 
class IPOPTLIB_EXPORT Observer
{
public:
#ifdef IP_DEBUG_OBSERVER
   static const Index dbg_verbosity;
#endif
 
 
   Observer()
   { }
 
   inline
   virtual ~Observer();
 
   enum NotifyType
   {
      NT_All,
      NT_BeingDestroyed,
      NT_Changed
   };
 
protected:
   inline
   void RequestAttach(
      NotifyType     notify_type,
      const Subject* subject
   );
 
   inline
   void RequestDetach(
      NotifyType     notify_type,
      const Subject* subject
   );
 
   virtual void ReceiveNotification(
      NotifyType     notify_type,
      const Subject* subject
   ) = 0;
 
private:
 
   Observer(
      const Observer&
   );
 
   void operator=(
      const Observer&
   );
 
   std::vector<const Subject*> subjects_;
 
   inline
   void ProcessNotification(
      NotifyType     notify_type,
      const Subject* subject
   );
 
   friend class Subject;
};
 
class IPOPTLIB_EXPORT Subject
{
public:
#ifdef IP_DEBUG_OBSERVER
   static const Index dbg_verbosity;
#endif
 
 
   Subject()
   { }
 
   inline
   virtual ~Subject();
 
 
   inline
   void AttachObserver(
      Observer::NotifyType notify_type,
      Observer*            observer
   ) const;
 
   inline
   void DetachObserver(
      Observer::NotifyType notify_type,
      Observer*            observer
   ) const;
 
protected:
 
   inline
   void Notify(
      Observer::NotifyType notify_type
   ) const;
 
private:
 
   Subject(
      const Subject&
   );
 
   void operator=(
      const Subject&
   );
 
   mutable std::vector<Observer*> observers_;
};
 
/* inline methods */
inline Observer::~Observer()
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Observer::~Observer", dbg_verbosity);
   if (DBG_VERBOSITY() >= 1)
   {
      for( size_t i = 0; i < subjects_.size(); ++i )
      {
         DBG_PRINT((1, "subjects_[%zd] = %p\n", i, (const void*)subjects_[i]));
      }
   }
#endif
   // Detach all subjects
   for( size_t i = subjects_.size(); i > 0; --i )
   {
#ifdef IP_DEBUG_OBSERVER
      DBG_PRINT((1, "About to detach subjects_[%zd] = %p\n", i, (const void*)subjects_[i - 1]));
#endif
 
      RequestDetach(NT_All, subjects_[i - 1]);
   }
}
 
inline
void Observer::RequestAttach(
   NotifyType     notify_type,
   const Subject* subject
)
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Observer::RequestAttach", dbg_verbosity);
 
   // Add the subject to the list if it does not already exist
   std::vector<const Subject*>::iterator attached_subject;
   attached_subject = std::find(subjects_.begin(), subjects_.end(), subject);
   DBG_ASSERT(attached_subject == subjects_.end());
   DBG_ASSERT(subject);
#endif
 
   // add the subject to the list
   subjects_.push_back(subject);
   // Attach the observer to the subject
   subject->AttachObserver(notify_type, this);
}
 
inline
void Observer::RequestDetach(
   NotifyType     notify_type,
   const Subject* subject
)
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Observer::RequestDetach", dbg_verbosity);
   DBG_PRINT((1, "Requesting detach of subject: %p\n", (const void*)subject));
   DBG_ASSERT(subject);
#endif
 
   if( subject )
   {
      std::vector<const Subject*>::iterator attached_subject;
      attached_subject = std::find(subjects_.begin(), subjects_.end(), subject);
#ifdef IP_DEBUG_OBSERVER
 
      DBG_ASSERT(attached_subject != subjects_.end());
#endif
 
      if( attached_subject != subjects_.end() )
      {
#ifdef IP_DEBUG_OBSERVER
         DBG_PRINT((1, "Removing subject: %p from the list\n", (const void*)subject));
#endif
 
         subjects_.erase(attached_subject);
      }
 
      // Detach the observer from the subject
      subject->DetachObserver(notify_type, this);
   }
}
 
inline
void Observer::ProcessNotification(
   NotifyType     notify_type,
   const Subject* subject
)
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Observer::ProcessNotification", dbg_verbosity);
   DBG_ASSERT(subject);
#endif
 
   if( subject )
   {
      std::vector<const Subject*>::iterator attached_subject;
      attached_subject = std::find(subjects_.begin(), subjects_.end(), subject);
 
      // We must be processing a notification for a
      // subject that was previously attached.
#ifdef IP_DEBUG_OBSERVER
 
      DBG_ASSERT(attached_subject != subjects_.end());
#endif
 
      this->ReceiveNotification(notify_type, subject);
 
      if( notify_type == NT_BeingDestroyed )
      {
         // the subject is going away, remove it from our list
         subjects_.erase(attached_subject);
      }
   }
}
 
inline Subject::~Subject()
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Subject::~Subject", dbg_verbosity);
#endif
 
   for( std::vector<Observer*>::iterator iter = observers_.begin(); iter != observers_.end(); ++iter )
   {
      (*iter)->ProcessNotification(Observer::NT_BeingDestroyed, this);
   }
}
 
inline
void Subject::AttachObserver(
   Observer::NotifyType /*notify_type*/,
   Observer*            observer
) const
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Subject::AttachObserver", dbg_verbosity);
   // current implementation notifies all observers of everything
   // they must filter the notifications that they are not interested
   // in (i.e. a hub, not a router)
   DBG_ASSERT(observer);
 
   std::vector<Observer*>::iterator attached_observer;
   attached_observer = std::find(observers_.begin(), observers_.end(), observer);
   DBG_ASSERT(attached_observer == observers_.end());
 
   DBG_ASSERT(observer);
#endif
 
   observers_.push_back(observer);
}
 
inline
void Subject::DetachObserver(
   Observer::NotifyType /*notify_type*/,
   Observer*            observer
) const
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Subject::DetachObserver", dbg_verbosity);
   DBG_ASSERT(observer);
#endif
 
   if( observer )
   {
      std::vector<Observer*>::iterator attached_observer;
      attached_observer = std::find(observers_.begin(), observers_.end(), observer);
#ifdef IP_DEBUG_OBSERVER
 
      DBG_ASSERT(attached_observer != observers_.end());
#endif
 
      if( attached_observer != observers_.end() )
      {
         observers_.erase(attached_observer);
      }
   }
}
 
inline
void Subject::Notify(
   Observer::NotifyType notify_type
) const
{
#ifdef IP_DEBUG_OBSERVER
   DBG_START_METH("Subject::Notify", dbg_verbosity);
#endif
 
   for( std::vector<Observer*>::iterator iter = observers_.begin(); iter != observers_.end(); ++iter )
   {
      (*iter)->ProcessNotification(notify_type, this);
   }
}
 
} // namespace Ipopt
 
#endif