Structure updated and intqpipopt files added

1 files changed, 366 insertions, 0 deletions

diff --git a/newstructure/thirdparty/linux/include/coin/IpObserver.hpp b/newstructure/thirdparty/linux/include/coin/IpObserver.hpp
new file mode 100644
index 0000000..b16f599
--- /dev/null
+++ b/newstructure/thirdparty/linux/include/coin/IpObserver.hpp
@@ -0,0 +1,366 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpObserver.hpp 2161 2013-01-01 20:39:05Z stefan $
+//
+// 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 COIN_IPOPT_CHECKLEVEL > 2
+# define IP_DEBUG_OBSERVER
+#endif
+#ifdef IP_DEBUG_OBSERVER
+# include "IpDebug.hpp"
+#endif
+
+namespace Ipopt
+{
+  /** Forward declarations */
+  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 recieve notifications
+   *  from a Subject should inherit off of 
+   *  Observer and overload the protected method,
+   *  RecieveNotification_(...).
+   */
+  class Observer
+  {
+  public:
+#ifdef IP_DEBUG_OBSERVER
+
+    static const Index dbg_verbosity;
+#endif
+
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    Observer()
+    {}
+
+    /** Default 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
+     * recieve the requested notification from 
+     * attached Subjects
+     */
+    virtual void RecieveNotification(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&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const Observer&);
+    //@}
+
+    /** A list of the subjects currently being
+     *  observed. */
+    std::vector<const Subject*> subjects_;
+
+    /** Private Method for Recieving Notification
+     *  should only be called by the friend class
+     *  Subject. This method will, in turn, call
+     *  the overloaded RecieveNotification 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 Subject
+  {
+  public:
+#ifdef IP_DEBUG_OBSERVER
+
+    static const Index dbg_verbosity;
+#endif
+
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    Subject()
+    {}
+
+    /** Default 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
+     *  recieve 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 recieving notifications). */
+    inline
+    void AttachObserver(Observer::NotifyType notify_type, Observer* observer) const;
+
+    /** Detach the specified observer
+     *  (i.e., no longer recieve 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&);
+
+    /** Overloaded Equals 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 (Index i=0; i<(Index)subjects_.size(); i++) {
+        DBG_PRINT((1,"subjects_[%d] = 0x%x\n", i, subjects_[i]));
+      }
+    }
+#endif
+    // Detach all subjects
+    for (Int i=(Int)(subjects_.size()-1); i>=0; i--) {
+#ifdef IP_DEBUG_OBSERVER
+      DBG_PRINT((1,"About to detach subjects_[%d] = 0x%x\n", i, subjects_[i]));
+#endif
+
+      RequestDetach(NT_All, subjects_[i]);
+    }
+  }
+
+  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: 0x%x\n", 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: 0x%x from the list\n", 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->RecieveNotification(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
+
+    std::vector<Observer*>::iterator iter;
+    for (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
+
+    std::vector<Observer*>::iterator iter;
+    for (iter = observers_.begin(); iter != observers_.end(); iter++) {
+      (*iter)->ProcessNotification(notify_type, this);
+    }
+  }
+
+
+} // namespace Ipopt
+
+#endif