Teuchos_ParameterList.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
//                    Teuchos: Common Tools Package
//                 Copyright (2004) 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 Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER


#ifndef TEUCHOS_PARAMETER_LIST_H
#define TEUCHOS_PARAMETER_LIST_H

#include "Teuchos_ParameterEntry.hpp" // class data element 
#include "Teuchos_TestForException.hpp"
#include "Teuchos_ConfigDefs.hpp"
#include "Teuchos_map.hpp"

namespace Teuchos {

class ParameterList {

  typedef Teuchos::map<string, ParameterEntry> Map;

  typedef Map::iterator Iterator;
  
public:

  /* Made this typedef public so that we can use iterators in 
   * converting to NOX parameter lists -- KL 7 August 2004 */
  typedef Map::const_iterator ConstIterator;
  

  ParameterList();
  
  ParameterList(const ParameterList& source);
  
  ~ParameterList();
  
  
  ParameterList& operator=(const ParameterList& source);
  
  template<typename T>
  void set(const string& name, T value);

  void set(const string& name, char* value) 
  { set( name, std::string(value) ); }

  void set(const string& name, const char* value) 
  { set( name, std::string(value) ); }

  void set(const string& name, ParameterList value)
  { sublist(name) = value; }

  void setEntry(const string& name, const ParameterEntry& entry)
  {params_[name] = entry;}
  
  
  template<typename T>
  T& get(const string& name, T def_value);
  
  std::string& get(const string& name, char* def_value)
  { return get(name, std::string(def_value)); }

  std::string& get(const string& name, const char* def_value)
  { return get(name, std::string(def_value)); }
  
  template<typename T>
  T& get(const string& name);
  
  template<typename T>
  const T& get(const string& name) const;  
  
  

  ParameterList& sublist(const string& name);
  
  const ParameterList& sublist(const string& name) const;
  

  bool isParameter(const string& name) const;
  
  bool isSublist(const string& name) const;
  
  template<typename T>
  bool isType(const string& name) const;

#ifndef DOXYGEN_SHOULD_SKIP_THIS  

  template<typename T>
  bool isType(const string& name, T* ptr) const;
#endif

  

  ostream& print(ostream& os, int indent = 0) const;
  
  void unused(ostream& os) const;


  /* Added these methods to facilitate conversion to NOX parameter lists 
   * -- KL 7 August 2004 */

  ConstIterator begin() const ;

  ConstIterator end() const ;

  const ParameterEntry& entry(ConstIterator i) const;
  
  const string& name(ConstIterator i) const;
  
private:
  
  ParameterEntry& entry(Iterator i);
  
private:
  
  Map params_;
};
  
  
  template<typename T>
  void ParameterList::set(const string& name, T value)
  {
    params_[name].setValue(value);
  }
  
  template<typename T>
  T& ParameterList::get(const string& name, T def_value)
  {
    ConstIterator i = params_.find(name);
    
    // The parameter was not found, add it to the list
    if (i == params_.end()) {
      params_[name].setValue(def_value, true);
      i = params_.find(name);
    } else {
      // The parameter was found, make sure it is the same type as T.
      TEST_FOR_EXCEPTION( !isType( name, (T*)NULL ), std::runtime_error,
        "get ( " << name << ", T def_value ) failed -- parameter is wrong type! " );
    }

    // Return the value of the parameter
    return getValue<T>(entry(i));
  }
  
  template<typename T>
  T& ParameterList::get(const string& name) 
  {
    ConstIterator i = params_.find(name);
    
    // This parameter was not found or is wrong type, throw an exception
    TEST_FOR_EXCEPTION( i == params_.end(), std::runtime_error,
      "get ( " << name << " ) failed -- parameter does not exist! " );
    TEST_FOR_EXCEPTION( !isType( name, (T*)NULL ), std::runtime_error,
      "get ( " << name << " ) failed -- parameter is wrong type! " );
    
    // Return the value.
    return getValue<T>(entry(i));
  }
  
  template<typename T>
  const T& ParameterList::get(const string& name) const
  {
    ConstIterator i = params_.find(name);
    
    // This parameter was not found, throw and exception
    TEST_FOR_EXCEPTION( i == params_.end(), std::runtime_error,
      "get ( " << name << " ) failed -- parameter does not exist! " );
    TEST_FOR_EXCEPTION( !isType( name, (T*)NULL ), std::runtime_error,
      "get ( " << name << " ) failed -- parameter is wrong type! " );
    
    // Return the default value for this type
    return getValue<T>(entry(i));
  }
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  template<typename T>
  bool ParameterList::isType(const string& name, T* ptr) const
  {
    ConstIterator i = params_.find(name);
    
    // If parameter doesn't exist, return false.
    if (i == params_.end()) 
      return false;
    // Try to cast the parameter to the type we think it should be.
    try {
      getValue<T>(entry(i));
    }
    catch( std::exception& e ) {
      return false;
  }
    // If no exception was thrown, we should be OK.
    return true;
  }
#endif
  
  template<typename T>
  bool ParameterList::isType(const string& name) const
  {
    ConstIterator i = params_.find(name);
    
    // If parameter doesn't exist, return false.
    if (i == params_.end()) 
      return false;
    // Try to cast the parameter to the type we think it should be.
    try {
      getValue<T>(entry(i));
    }
    catch( std::exception& e ) {
      return false;
    }
    // If no exception was thrown, we should be OK.
    return true;
  }
  
  
  template<typename T>
  T& getParameter( ParameterList& l, const string& name )
  {
    T temp_var;
    // CAREFUL:  We need to be sure the parameter exists before using the temp variable to get the parameter.
    // This parameter was not found or is wrong type, throw an exception
    TEST_FOR_EXCEPTION( !l.isParameter( name ), std::runtime_error,
      "getParameter ( " << name << " ) failed -- parameter does not exist! " );
    TEST_FOR_EXCEPTION( !l.isType( name, &temp_var ), std::runtime_error,
      "getParameter ( " << name << " ) failed -- parameter is wrong type! " );
    //
    // This parameter exists and is of the right type, so we can retrieve it safely.    
    //
    return l.get( name, temp_var );
  }
  
  template<typename T>
  const T& getParameter( const ParameterList& l, const string& name )
  {
    T temp_var;
    // CAREFUL:  We need to be sure the parameter exists before using the temp variable to get the parameter.
    // This parameter was not found or is wrong type, throw an exception
    TEST_FOR_EXCEPTION( !l.isParameter( name ), std::runtime_error,
      "getParameter ( " << name << " ) failed -- parameter does not exist! " );
    TEST_FOR_EXCEPTION( !l.isType( name, &temp_var ), std::runtime_error,
      "getParameter ( " << name << " ) failed -- parameter is wrong type! " );
    //
    // This parameter exists and is of the right type, so we can retrieve it safely.    
    //
    return l.get( name, temp_var );
  }
  
  template<typename T>
  bool isParameterType( ParameterList& l, const string& name )
  {
    return l.isType( name, (T*)NULL );
  }
  
  template<typename T>
  bool isParameterType( const ParameterList& l, const string& name )
  {
    return l.isType( name, (T*)NULL );
  }
  
  inline ostream& operator<<(ostream& os, const ParameterList& l)
  {
    return l.print(os);
  }
  
} // end of Teuchos namespace

#endif

---