IpOptionsList.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 __IPOPTLIST_HPP__
#define __IPOPTLIST_HPP__
 
#include "IpUtils.hpp"
#include "IpReferenced.hpp"
#include "IpException.hpp"
#include "IpRegOptions.hpp"
 
#include <iostream>
#include <map>
 
namespace Ipopt
{
DECLARE_STD_EXCEPTION(OPTION_INVALID);
 
class IPOPTLIB_EXPORT OptionsList: public ReferencedObject
{
   class OptionValue
   {
   public:
 
      OptionValue()
         : initialized_(false)
      { }
 
      OptionValue(
         std::string value,
         bool        allow_clobber,
         bool        dont_print
      )
         : value_(value),
           counter_(0),
           initialized_(true),
           allow_clobber_(allow_clobber),
           dont_print_(dont_print)
      {
      }
 
      OptionValue(
         const OptionValue& copy
      )
         : value_(copy.value_),
           counter_(copy.counter_),
           initialized_(copy.initialized_),
           allow_clobber_(copy.allow_clobber_),
           dont_print_(copy.dont_print_)
      {
      }
 
      void operator=(
         const OptionValue& copy
      )
      {
         value_ = copy.value_;
         counter_ = copy.counter_;
         initialized_ = copy.initialized_;
         allow_clobber_ = copy.allow_clobber_;
         dont_print_ = copy.dont_print_;
      }
 
      ~OptionValue()
      { }
 
      std::string GetValue() const
      {
         DBG_ASSERT(initialized_);
         counter_++;
         return value_;
      }
 
      std::string Value() const
      {
         DBG_ASSERT(initialized_);
         return value_;
      }
 
      Index Counter() const
      {
         DBG_ASSERT(initialized_);
         return counter_;
      }
 
      bool AllowClobber() const
      {
         DBG_ASSERT(initialized_);
         return allow_clobber_;
      }
 
      bool DontPrint() const
      {
         DBG_ASSERT(initialized_);
         return dont_print_;
      }
 
   private:
      std::string value_;
 
      mutable Index counter_;
 
      bool initialized_;
 
      bool allow_clobber_;
 
      bool dont_print_;
   };
 
public:
   OptionsList(
      SmartPtr<RegisteredOptions> reg_options,
      SmartPtr<Journalist>        jnlst
   )
      : reg_options_(reg_options),
        jnlst_(jnlst)
   { }
 
   OptionsList()
   { }
 
   OptionsList(
      const OptionsList& copy
   )
   {
      // copy all the option strings and values
      options_ = copy.options_;
      // copy the registered options pointer
      reg_options_ = copy.reg_options_;
   }
 
   virtual ~OptionsList()
   { }
 
   virtual void operator=(
      const OptionsList& source
   )
   {
      options_ = source.options_;
      reg_options_ = source.reg_options_;
      jnlst_ = source.jnlst_;
   }
 
   virtual void clear()
   {
      options_.clear();
   }
 
   virtual void SetRegisteredOptions(
      const SmartPtr<RegisteredOptions> reg_options
   )
   {
      reg_options_ = reg_options;
   }
 
   virtual void SetJournalist(
      const SmartPtr<Journalist> jnlst
   )
   {
      jnlst_ = jnlst;
   }
 
 
   virtual bool SetStringValue(
      const std::string& tag,
      const std::string& value,
      bool               allow_clobber = true,
      bool               dont_print = false
   );
 
   virtual bool SetNumericValue(
      const std::string& tag,
      Number             value,
      bool               allow_clobber = true,
      bool               dont_print = false
   );
 
   virtual bool SetIntegerValue(
      const std::string& tag,
      Index              value,
      bool               allow_clobber = true,
      bool               dont_print = false
   );
 
   virtual bool SetStringValueIfUnset(
      const std::string& tag,
      const std::string& value,
      bool               allow_clobber = true,
      bool               dont_print = false
   );
 
   virtual bool SetNumericValueIfUnset(
      const std::string& tag,
      Number             value,
      bool               allow_clobber = true,
      bool               dont_print = false
   );
 
   virtual bool SetIntegerValueIfUnset(
      const std::string& tag,
      Index              value,
      bool               allow_clobber = true,
      bool               dont_print = false
   );
 
   virtual bool GetStringValue(
      const std::string& tag,
      std::string&       value,
      const std::string& prefix
   ) const;
 
   virtual bool GetEnumValue(
      const std::string& tag,
      Index&             value,
      const std::string& prefix
   ) const;
 
   virtual bool GetBoolValue(
      const std::string& tag,
      bool&              value,
      const std::string& prefix
   ) const;
 
   virtual bool GetNumericValue(
      const std::string& tag,
      Number&            value,
      const std::string& prefix
   ) const;
 
   virtual bool GetIntegerValue(
      const std::string& tag,
      Index&             value,
      const std::string& prefix
   ) const;
 
   virtual void PrintList(
      std::string& list
   ) const;
 
   virtual void PrintUserOptions(
      std::string& list
   ) const;
 
   virtual bool ReadFromStream(
      const Journalist& jnlst,
      std::istream&     is,
      bool              allow_clobber = false
   );
 
private:
 
   //    OptionsList();
 
   std::map<std::string, OptionValue> options_;
 
   SmartPtr<RegisteredOptions> reg_options_;
 
   SmartPtr<Journalist> jnlst_;
 
   const std::string& lowercase(
      const std::string tag
   ) const;
 
   bool find_tag(
      const std::string& tag,
      const std::string& prefix,
      std::string&       value
   ) const;
 
   bool will_allow_clobber(
      const std::string& tag
   ) const;
 
   bool readnexttoken(
      std::istream& is,
      std::string&  token
   );
 
   mutable std::string lowercase_buffer_;
};
 
} // namespace Ipopt
 
#endif