OptionsFromStreamPack_OptionsFromStream.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef OPTIONS_FROM_STREAM_H
#define OPTIONS_FROM_STREAM_H

#include "Moocho_ConfigDefs.hpp"

// /////////////////////////////////////////////////
// Forward declarations.

namespace OptionsFromStreamPack {
  namespace OptionsFromStreamUtilityPack {

    // Simple class for a boolean variable that is false on construction.
    class false_bool_t {
    public:
      false_bool_t() : val_(false) {}
      void set(bool val) { val_ = val; }
      operator bool() const { return val_; }
    private:
      bool val_;
    };

    // Implementation type for the map for looking up a value given
    // a an options name.
    typedef std::map< std::string , std::string >     option_to_value_map_t;

    // Implementation type for an options group's options and
    // a boolean variable to determine if this option has been visited yet.
    typedef std::pair< option_to_value_map_t, false_bool_t >  options_group_pair_t;

    // Implementation type of the map for looking up a set of options
    // given the option groups name.
    typedef std::map< std::string, options_group_pair_t > options_group_map_t;

    // The above declarations sets up the data structure:
    // 
    //       map<string,options_group_pair_t> (options_group_map_t)
    //                  |
    //                  | value_type
    //                 `.'
    //       pair<string,options_group_pair_t> 
    //                  |
    //       -----------------------              
    //      |                       |         
    //      | first                 | second
    //     `.'                     `.'
    //    string         pair<option_to_value_map_t,false_bool_t> (options_group_pair_t)
    //      |                      |
    // "solver_options"            |
    //                             |
    //        ------------------------------------------------
    //       |                                                |
    //       | first                                          | second
    //      `.'                                              `.'
    //    map<string,string> (option_to_value_map_t)       false_bool_t
    //       |                                                |
    //       | value_type                                   "true"
    //      `.'
    // pair<string,string>
    //       |
    //     --------------
    //    | first        | second
    //   `.'            `.'
    //  string         string
    //    |              |    
    //  "tol"          "1e-6"
    //  

    class OptionsGroup;
  }
  class OptionsFromStream;
}

// //////////////////////////////////////////////////
// Class and function declarations

namespace OptionsFromStreamPack {

/* \defgroup OptionsFromStreamPack_grp Untilities for maintianing a simple options database.
 * \ingroup Misc_grp
 * 
 */
// @ {

namespace OptionsFromStreamUtilityPack {

class OptionsGroup {
public:

  // friends
  friend class OptionsFromStream;


  typedef option_to_value_map_t::iterator     iterator;
  typedef option_to_value_map_t::const_iterator const_iterator;





  std::string& option_value( const std::string& option_name );
  const std::string& option_value( const std::string& option_name ) const;


  static bool option_exists( const std::string& option_value );

  bool options_group_exists() const;


  int       num_options() const;
  iterator    begin();
  iterator    end();
  const_iterator  begin() const;
  const_iterator  end() const;


private:
  
  option_to_value_map_t*  option_to_value_map_; // 0 used for no options group.
  static std::string    option_does_not_exist_;

  // Not defined and not to be called
  OptionsGroup();
  OptionsGroup& operator=(const OptionsGroup&);

public:
  // Is given zero by OptionsFromStream to signify the option group does't exist.
  // It is put here to keep it away from the eyes of the general user.
  OptionsGroup( option_to_value_map_t* option_to_value_map );

};  // end class OptionsGroup

inline
const std::string& option_name( OptionsGroup::const_iterator& itr ) {
  return (*itr).first;
}

inline
const std::string& option_value( OptionsGroup::const_iterator& itr ) {
  return (*itr).second;
}


// @ }

} // end namespace OptionsFromStreamUtilityPack 


class OptionsFromStream {
public:


  typedef OptionsFromStreamUtilityPack::options_group_map_t::iterator     iterator;
  typedef OptionsFromStreamUtilityPack::options_group_map_t::const_iterator const_iterator;

  typedef OptionsFromStreamUtilityPack::OptionsGroup              options_group_t;

  class InputStreamError : public std::logic_error
  {public: InputStreamError(const std::string& what_arg) : std::logic_error(what_arg) {}};



  OptionsFromStream();

  explicit OptionsFromStream( std::istream& in );

  void clear_options();

  void read_options( std::istream& in );


  void print_options( std::ostream& out ) const;


  options_group_t options_group( const std::string& options_group_name );
  const options_group_t options_group( const std::string& options_group_name ) const;


  static bool options_group_exists( const options_group_t& options_group );


  void reset_unaccessed_options_groups();

  void print_unaccessed_options_groups( std::ostream& out ) const;



  int       num_options_groups() const;
  iterator    begin();
  iterator    end();
  const_iterator  begin() const;
  const_iterator  end() const;


private:
  typedef OptionsFromStreamUtilityPack::false_bool_t      false_bool_t;
  typedef OptionsFromStreamUtilityPack::option_to_value_map_t option_to_value_map_t;
  typedef OptionsFromStreamUtilityPack::options_group_map_t options_group_map_t;
  options_group_map_t                     options_group_map_;

};  // end class OptionsFromStream

inline
const std::string&
options_group_name( OptionsFromStream::const_iterator& itr )
{
  return (*itr).first;
}

inline
const OptionsFromStream::options_group_t
options_group( OptionsFromStream::const_iterator& itr )
{
  return OptionsFromStream::options_group_t(
    const_cast<OptionsFromStreamUtilityPack::option_to_value_map_t*>(&(*itr).second.first) );
}


// @ }

/* @name Return the name or value of an option from an OptionsGroup iterator. */
// @ {

//
using OptionsFromStreamUtilityPack::option_name;
//
using OptionsFromStreamUtilityPack::option_value;

// @ }

//  end namespace OptionsFromStreamPack 
// @ }

} // end namespace OptionsFromStreamPack

// //////////////////////////////////////////////////////////////////////////////////////////
// Inline definitions.

namespace OptionsFromStreamPack {

namespace OptionsFromStreamUtilityPack {

// class OptionsGroup.

inline
std::string& OptionsGroup::option_value( const std::string& option_name ) {
  option_to_value_map_t::iterator itr = option_to_value_map_->find( option_name );
  return ( itr != option_to_value_map_->end() ? (*itr).second : option_does_not_exist_ );
}

inline
const std::string& OptionsGroup::option_value( const std::string& option_name ) const {
  option_to_value_map_t::const_iterator itr = option_to_value_map_->find( option_name );
  return ( itr != option_to_value_map_->end() ? (*itr).second : option_does_not_exist_ );
}

inline
bool OptionsGroup::option_exists( const std::string& option_value ) {
  return &option_value != &option_does_not_exist_;
}

inline
bool OptionsGroup::options_group_exists() const {
  return option_to_value_map_ != 0;
}

inline
int OptionsGroup::num_options() const {
  return option_to_value_map_->size();
}

inline
OptionsGroup::iterator    OptionsGroup::begin() {
  return option_to_value_map_->begin();
}

inline
OptionsGroup::iterator    OptionsGroup::end() {
  return option_to_value_map_->end();
}

inline
OptionsGroup::const_iterator  OptionsGroup::begin() const {
  return option_to_value_map_->begin();
}

inline
OptionsGroup::const_iterator  OptionsGroup::end() const {
  return option_to_value_map_->end();
}

inline
OptionsGroup::OptionsGroup( option_to_value_map_t* option_to_value_map )
  : option_to_value_map_(option_to_value_map)
{}

} // end namespace OptionsFromStreamPack

// class OptionsFromStream

inline
OptionsFromStream::OptionsFromStream()
{}

inline
OptionsFromStream::OptionsFromStream( std::istream& in ) {
  read_options(in);
}

inline
void OptionsFromStream::clear_options() {
  options_group_map_.clear();
}

inline
bool OptionsFromStream::options_group_exists( const options_group_t& options_group )
{
  return options_group.options_group_exists();
}

inline
int OptionsFromStream::num_options_groups() const {
  return options_group_map_.size();
}

inline
OptionsFromStream::iterator OptionsFromStream::begin() {
  return options_group_map_.begin();
}

inline
OptionsFromStream::iterator OptionsFromStream::end() {
  return options_group_map_.end();
}

inline
OptionsFromStream::const_iterator OptionsFromStream::begin() const {
  return options_group_map_.begin();
}

inline
OptionsFromStream::const_iterator OptionsFromStream::end() const {
  return options_group_map_.end();
}

} // end namespace OptionsFromStreamPack

#endif  // OPTIONS_FROM_STREAM_H

---