casadi 3.6.4__cp35-none-manylinux1_i686.whl → 3.6.6__cp35-none-manylinux1_i686.whl

casadi/include/coin-or/IpObserver.hpp

@@ -0,0 +1,422 @@
+// 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;
+
+/** Slight Variation of the Observer Design Pattern.
+ *
+ *  This class implements the Observer class of the
+ *  Observer Design Pattern. An Observer "Attach"es
+ *  to a Subject, indicating that it would like to
+ *  be notified of changes in the Subject.
+ *  Any derived class wishing to receive notifications
+ *  from a Subject should inherit off of
+ *  Observer and overload the protected method,
+ *  ReceiveNotification_(...).
+ */
+class IPOPTLIB_EXPORT Observer
+{
+public:
+#ifdef IP_DEBUG_OBSERVER
+   static const Index dbg_verbosity;
+#endif
+
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default Constructor */
+   Observer()
+   { }
+
+   /** Destructor */
+   inline
+   virtual ~Observer();
+   ///@}
+
+   /** Enumeration specifying the type of notification */
+   enum NotifyType
+   {
+      NT_All,
+      NT_BeingDestroyed,
+      NT_Changed
+   };
+
+protected:
+   /** Derived classes should call this method
+    * to request an "Attach" to a Subject.
+    *
+    * Do not call "Attach" explicitly on the Subject
+    * since further processing is done here
+    */
+   inline
+   void RequestAttach(
+      NotifyType     notify_type,
+      const Subject* subject
+   );
+
+   /** Derived classes should call this method
+    * to request a "Detach" to a Subject.
+    *
+    * Do not call "Detach" explicitly on the Subject
+    * since further processing is done here
+    */
+   inline
+   void RequestDetach(
+      NotifyType     notify_type,
+      const Subject* subject
+   );
+
+   /** Derived classes should overload this method to
+    * receive the requested notification from
+    * attached Subjects
+    */
+   virtual void ReceiveNotification(
+      NotifyType     notify_type,
+      const Subject* subject
+   ) = 0;
+
+private:
+   /**@name Default Compiler Generated Methods
+    * (Hidden to avoid implicit creation/calling).
+    *
+    * These methods are not implemented and
+    * we do not want the compiler to implement
+    * them for us, so we declare them private
+    * and do not define them. This ensures that
+    * they will not be implicitly created/called.
+    */
+   ///@{
+   /** Copy Constructor */
+   Observer(
+      const Observer&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const Observer&
+   );
+   ///@}
+
+   /** A list of the subjects currently being observed. */
+   std::vector<const Subject*> subjects_;
+
+   /** Private Method for Receiving Notification
+    *  should only be called by the friend class
+    *  Subject.
+    *
+    *  This method will, in turn, call
+    *  the overloaded ReceiveNotification method
+    *  for the derived class to process.
+    */
+   inline
+   void ProcessNotification(
+      NotifyType     notify_type,
+      const Subject* subject
+   );
+
+   friend class Subject;
+};
+
+/** Slight Variation of the Observer Design Pattern (Subject part).
+ *
+ *  This class implements the Subject class of the Observer Design
+ *  Pattern. An Observer "Attach"es to a Subject, indicating that it
+ *  would like to be notified of changes in the Subject.  Any
+ *  derived class that is to be observed has to inherit off the
+ *  Subject base class.  If the subject needs to notify the
+ *  Observer, it calls the Notify method.
+ */
+class IPOPTLIB_EXPORT Subject
+{
+public:
+#ifdef IP_DEBUG_OBSERVER
+   static const Index dbg_verbosity;
+#endif
+
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default Constructor */
+   Subject()
+   { }
+
+   /** Destructor */
+   inline
+   virtual ~Subject();
+   ///@}
+
+   /**@name Methods to Add and Remove Observers.
+    *
+    *  Currently, the notify_type flags are not used,
+    *  and Observers are attached in general and will
+    *  receive all notifications (of the type requested
+    *  and possibly of types not requested). It is
+    *  up to the observer to ignore the types they
+    *  are not interested in. The NotifyType in the
+    *  parameter list is so a more efficient mechanism
+    *  depending on type could be implemented later if
+    *  necessary.
+    */
+   ///@{
+   /** Attach the specified observer
+    *  (i.e., begin receiving notifications). */
+   inline
+   void AttachObserver(
+      Observer::NotifyType notify_type,
+      Observer*            observer
+   ) const;
+
+   /** Detach the specified observer
+    *  (i.e., no longer receive notifications). */
+   inline
+   void DetachObserver(
+      Observer::NotifyType notify_type,
+      Observer*            observer
+   ) const;
+   ///@}
+
+protected:
+
+   inline
+   void Notify(
+      Observer::NotifyType notify_type
+   ) const;
+
+private:
+   /**@name Default Compiler Generated Methods
+    * (Hidden to avoid implicit creation/calling).
+    *
+    * These methods are not implemented and
+    * we do not want the compiler to implement
+    * them for us, so we declare them private
+    * and do not define them. This ensures that
+    * they will not be implicitly created/called.
+    */
+   ///@{
+   /** Copy Constructor */
+   Subject(
+      const Subject&
+   );
+
+   /** Default Assignment Operator */
+   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