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.
//
// $Id: IpOptionsList.hpp 2613 2015-11-04 14:42:02Z stefan $
//
// 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 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