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_ParameterListExceptions.hpp"
#include "Teuchos_ParameterEntry.hpp"
#include "Teuchos_TestForException.hpp"
#include "Teuchos_RCP.hpp"
#include "Teuchos_Array.hpp"
#include "Teuchos_map.hpp"

namespace Teuchos {

enum EValidateUsed {
  VALIDATE_USED_ENABLED   /*< \brief Validate that parameters in <tt>*this</tt> list
                              set using the default value are present in
                              the validation list */
  ,VALIDATE_USED_DISABLED /*< \brief Do not validate that parameters in <tt>*this</tt> list
                              set using the default value are present in
                              the validation list */
};

enum EValidateDefaults {
  VALIDATE_DEFAULTS_ENABLED   /*< \brief Validate that parameters in <tt>*this</tt> list
                                  set using the default value are present in
                                   the validation list */
  ,VALIDATE_DEFAULTS_DISABLED /*< \brief Do not validate that parameters in <tt>*this</tt> list
                                  set using the default value are present in
                                  the validation list */
};

class ParameterList {

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

  typedef Map::iterator Iterator;
  
public:



  typedef Map::const_iterator ConstIterator;

  class PrintOptions {
  public:
    PrintOptions() : indent_(0), showTypes_(false), showFlags_(false), showDoc_(false) {}
    PrintOptions& indent(int _indent)        { indent_ = _indent; return *this; }
    PrintOptions& showTypes(bool _showTypes) { showTypes_ = _showTypes; return *this; }
    PrintOptions& showFlags(bool _showFlags) { showFlags_ = _showFlags; return *this; }
    PrintOptions& showDoc(bool _showDoc)     { showDoc_ = _showDoc; return *this; }
    PrintOptions& incrIndent(int indents)    { indent_ += indents; return *this; }
    int indent() const { return indent_; }
    bool showTypes() const { return showTypes_; }
    bool showFlags() const { return showFlags_; }
    bool showDoc() const { return showDoc_; }
    PrintOptions copy() const { return PrintOptions(*this); }
  private:
    int    indent_;
    bool   showTypes_;
    bool   showFlags_;
    bool   showDoc_;
  };

  


  ParameterList();

  ParameterList(const std::string &name);
  
  ParameterList(const ParameterList& source);
  
  virtual ~ParameterList();

  


  ParameterList& setName( const std::string &name );
  
  ParameterList& operator=(const ParameterList& source);
  
  ParameterList& setParameters(const ParameterList& source);
  
  ParameterList& setParametersNotAlreadySet(const ParameterList& source);

  ParameterList& disableRecursiveValidation();
  
  template<typename T>
  ParameterList& set(
    std::string const& name, T const& value, std::string const& docString = ""
    ,RCP<const ParameterEntryValidator> const& validator = null
    );

  ParameterList& set(
    std::string const& name, char value[], std::string const& docString = ""
    ,RCP<const ParameterEntryValidator> const& validator = null
    );

  ParameterList& set(
    std::string const& name, const char value[], std::string const& docString = ""
    ,RCP<const ParameterEntryValidator> const& validator = null
    );

  ParameterList& set(
    std::string const& name, ParameterList const& value, std::string const& docString = ""
    );

  ParameterList& setEntry(const std::string& name, const ParameterEntry& entry);

  

  
  template<typename T>
  T& get(const std::string& name, T def_value);

  std::string& get(const std::string& name, char def_value[]);
  
  std::string& get(const std::string& name, const char def_value[]);
  
  template<typename T>
  T& get(const std::string& name);
  
  template<typename T>
  const T& get(const std::string& name) const;  
  
  template<typename T>
  inline
  T* getPtr(const std::string& name);
  
  template<typename T>
  inline
  const T* getPtr(const std::string& name) const;  
  
  ParameterEntry& getEntry(const std::string& name);  
  
  inline
  const ParameterEntry& getEntry(const std::string& name) const;  
  
  inline
  ParameterEntry* getEntryPtr(const std::string& name);  
  
  inline
  const ParameterEntry* getEntryPtr(const std::string& name) const;  



 
  bool remove(
    std::string const& name, bool throwIfNotExists = true
    );

  


  ParameterList& sublist(
    const std::string& name, bool mustAlreadyExist = false
    ,const std::string& docString = ""
    );
  
  const ParameterList& sublist(const std::string& name) const;

  


  const std::string& name() const;

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

#ifndef DOXYGEN_SHOULD_SKIP_THIS  

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

  


  std::ostream& print(std::ostream& os, const PrintOptions &printOptions) const;

  std::ostream& print(std::ostream& os, int indent = 0, bool showTypes = false, bool showFlags = true ) const;
  
  void unused(std::ostream& os) const;

  std::string currentParametersString() const;




  ConstIterator begin() const ;

  ConstIterator end() const ;

  const ParameterEntry& entry(ConstIterator i) const;
  
  const std::string& name(ConstIterator i) const;




  void validateParameters(
    ParameterList const& validParamList,
    int const depth = 1000,
    EValidateUsed const validateUsed = VALIDATE_USED_ENABLED,
    EValidateDefaults const validateDefaults = VALIDATE_DEFAULTS_ENABLED
    ) const;

  void validateParametersAndSetDefaults(
    ParameterList const& validParamList,
    int const depth = 1000
    );

  
private: // Functions
 
  Iterator nonconstBegin();
  Iterator nonconstEnd();
  ParameterEntry& entry(Iterator i);
  void validateEntryExists( const std::string &funcName, const std::string &name, const ParameterEntry *entry ) const;
  template<typename T>
  void validateEntryType( const std::string &funcName, const std::string &name, const ParameterEntry &entry ) const;
  void updateSubListNames(int depth = 0);
  
private: // Data members

  std::string name_;
  Map params_;
  bool disableRecursiveValidation_;

};


inline
RCP<ParameterList> parameterList()
{
  return rcp(new ParameterList);
}


inline
RCP<ParameterList> parameterList(const std::string &name)
{
  return rcp(new ParameterList(name));
}
  
inline
RCP<ParameterList> parameterList(const ParameterList& source)
{
  return rcp(new ParameterList(source));
}



template<>
class TypeNameTraits<ParameterList> {
public:
  static std::string name() { return "ParameterList"; }
  static std::string concreteName( const ParameterList& /*t2*/ )
    { return name(); }
};

bool operator==( const ParameterList& list1, const ParameterList& list2 );

inline
bool operator!=( const ParameterList& list1, const ParameterList& list2 )
{
  return !( list1 == list2 );
}

bool haveSameValues( const ParameterList& list1, const ParameterList& list2 );

// /////////////////////////////////////////////////////
// Inline and Template Function Definitions

inline
ParameterList& ParameterList::setName( const std::string &name_in )
{
  name_ = name_in;
  return *this;
}

// Set functions

template<typename T>
inline
ParameterList& ParameterList::set(
  std::string const& name_in, T const& value_in, std::string const& docString_in,
  RCP<const ParameterEntryValidator> const& validator_in
  )
{
  ParameterEntry &foundEntry = params_[name_in]; // Will add the entry if not exists
  foundEntry.setValue(value_in,false,docString_in,validator_in);
  // Validate the value *after* you set it.  It is important to use
  // entry.validator() instead of validator since validator might be null!
  if(foundEntry.validator().get())
    foundEntry.validator()->validate(foundEntry,name_in,this->name());
  return *this;
}

inline
ParameterList& ParameterList::set(
  std::string const& name_in, char value[], std::string const& docString
  ,RCP<const ParameterEntryValidator> const& validator
  ) 
{ return set( name_in, std::string(value), docString, validator ); }

inline
ParameterList& ParameterList::set(
  const std::string& name_in, const char value[], const std::string &docString
  ,RCP<const ParameterEntryValidator> const& validator
  ) 
{ return set( name_in, std::string(value), docString, validator ); }

inline
ParameterList& ParameterList::set(
  std::string const& name_in, ParameterList const& value, std::string const& /*docString*/
  )
{
  sublist(name_in) = value;
  return *this;
}

inline
ParameterList& ParameterList::setEntry(std::string const& name_in, ParameterEntry const& entry_in)
{
  params_[name_in] = entry_in;
  return *this;
}

// Get functions

template<typename T>
T& ParameterList::get(const std::string& name_in, T def_value)
{
  ConstIterator i = params_.find(name_in);
    
  // The parameter was not found, add it to the list
  if (i == params_.end()) {
    params_[name_in].setValue(def_value, true);
    i = params_.find(name_in);
  } else {
    // The parameter was found, make sure it is the same type as T.
    this->template validateEntryType<T>("get", name_in, entry(i));
  }

  // Return the value of the parameter
  return getValue<T>(entry(i));
}

inline
std::string& ParameterList::get(const std::string& name_in, char def_value[])
{ return get(name_in, std::string(def_value)); }

inline
std::string& ParameterList::get(const std::string& name_in, const char def_value[])
{ return get(name_in, std::string(def_value)); }

template<typename T>
T& ParameterList::get(const std::string& name_in) 
{
  ParameterEntry *foundEntry = this->getEntryPtr(name_in);
  validateEntryExists("get",name_in,foundEntry);
  this->template validateEntryType<T>("get",name_in,*foundEntry);
  return getValue<T>(*foundEntry);
}
  
template<typename T>
const T& ParameterList::get(const std::string& name_in) const
{
  const ParameterEntry *foundEntry = this->getEntryPtr(name_in);
  validateEntryExists("get",name_in,foundEntry);
  this->template validateEntryType<T>("get",name_in,*foundEntry);
  return getValue<T>(*foundEntry);
}

template<typename T>
inline
T* ParameterList::getPtr(const std::string& name_in) 
{
  ConstIterator i = params_.find(name_in);
  if ( i == params_.end() || entry(i).getAny().type() != typeid(T) )
    return NULL;
  return &getValue<T>(entry(i));
}
  
template<typename T>
inline
const T* ParameterList::getPtr(const std::string& name_in) const
{
  ConstIterator i = params_.find(name_in);
  if ( i == params_.end() || entry(i).getAny().type() != typeid(T) )
    return NULL;
  return &getValue<T>(entry(i));
}

inline
ParameterEntry& ParameterList::getEntry(const std::string& name_in)
{
  ParameterEntry *foundEntry = this->getEntryPtr(name_in);
  validateEntryExists("get",name_in,foundEntry);
  return *foundEntry;
}
  
inline
const ParameterEntry& ParameterList::getEntry(const std::string& name_in) const
{
  const ParameterEntry *foundEntry = this->getEntryPtr(name_in);
  validateEntryExists("get",name_in,foundEntry);
  return *foundEntry;
}

inline
ParameterEntry*
ParameterList::getEntryPtr(const std::string& name_in)
{
  Map::iterator i = params_.find(name_in);
  if ( i == params_.end() )
    return NULL;
  return &entry(i);
}

inline
const ParameterEntry*
ParameterList::getEntryPtr(const std::string& name_in) const
{
  ConstIterator i = params_.find(name_in);
  if ( i == params_.end() )
    return NULL;
  return &entry(i);
}

// Attribute Functions

inline
const std::string& ParameterList::name() const
{
  return name_;
}
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<typename T>
bool ParameterList::isType(const std::string& name_in, T* /*ptr*/) const
{
  ConstIterator i = params_.find(name_in);
  // If parameter doesn't exist, return false.
  if (i == params_.end()) 
    return false;
  return entry(i).getAny().type() == typeid(T);
}
#endif
  
template<typename T>
bool ParameterList::isType(const std::string& name_in) const
{
  ConstIterator i = params_.find(name_in);
  // If parameter doesn't exist, return false.
  if (i == params_.end()) 
    return false;
  return entry(i).getAny().type() == typeid(T);
}


// private


template<typename T>
inline
void ParameterList::validateEntryType(
  const std::string &/*funcName*/, const std::string &name_in,
  const ParameterEntry &entry_in
  ) const
{
  TEST_FOR_EXCEPTION_PURE_MSG(
    entry_in.getAny().type() != typeid(T), Exceptions::InvalidParameterType
    ,"Error!  An attempt was made to access parameter \""<<name_in<<"\""
    " of type \""<<entry_in.getAny().typeName()<<"\""
    "\nin the parameter (sub)list \""<<this->name()<<"\""
    "\nusing the incorrect type \""<<TypeNameTraits<T>::name()<<"\"!"
    );
}

// //////////////////////////////////////
// Helper functions
  
template<typename T>
T& getParameter( ParameterList& l, const std::string& name )
{
  return l.template get<T>(name);
}
  
template<typename T>
inline
T& get( ParameterList& l, const std::string& name )
{
  return getParameter<T>(l,name);
}
  
template<typename T>
const T& getParameter( const ParameterList& l, const std::string& name )
{
  return l.template get<T>(name);
}
  
template<typename T>
inline
T* getParameterPtr( ParameterList& l, const std::string& name )
{
  return l.template getPtr<T>(name);
}
  
template<typename T>
inline
const T* getParameterPtr( const ParameterList& l, const std::string& name )
{
  return l.template getPtr<T>(name);
}
  
template<typename T>
inline
bool isParameterType( ParameterList& l, const std::string& name )
{
  return l.isType( name, (T*)NULL );
}
  
template<typename T>
inline
bool isParameterType( const ParameterList& l, const std::string& name )
{
  return l.isType( name, (T*)NULL );
}
  
template<typename T>
void setStringParameterFromArray(
  const std::string          &paramName
  ,const Array<T>       &array
  ,ParameterList        *paramList
  )
{
  TEST_FOR_EXCEPT(!paramList);
  paramList->set(paramName,toString(array));
}
  
template<typename T>
Array<T> getArrayFromStringParameter(
  const ParameterList   &paramList
  ,const std::string         &paramName
  ,const int            arrayDim        = -1
  ,const bool           mustExist       = true
  )
{
  std::string arrayStr;
  if(mustExist) {
    arrayStr = getParameter<std::string>(paramList,paramName);
  }
  else {
    const std::string
      *arrayStrPtr = getParameterPtr<std::string>(paramList,paramName);
    if(arrayStrPtr) {
      arrayStr = *arrayStrPtr;
    }
    else {
      return Array<T>(); // Return an empty array
    }
  }
  Array<T> a;
  try {
    a = fromStringToArray<T>(arrayStr);
  }
  catch( const InvalidArrayStringRepresentation&) {
    TEST_FOR_EXCEPTION_PURE_MSG(
      true, Exceptions::InvalidParameterValue
      ,"Error!  The parameter \""<<paramName<<"\"\n"
      "in the sublist \""<<paramList.name()<<"\"\n"
      "exists, but the std::string value:\n"
      "----------\n"
      <<arrayStr<<
      "\n----------\n"
      "is not a valid array represntation!"
      );
  }
  TEST_FOR_EXCEPTION_PURE_MSG(
    ( ( a.size()>0 && arrayDim>=0 ) && static_cast<int>(a.size())!=arrayDim )
    ,Exceptions::InvalidParameterValue
    ,"Error!  The parameter \""<<paramName<<"\"\n"
    "in the sublist \""<<paramList.name()<<"\"\n"
    "exists and is a valid array, but the dimension of\n"
    "the read in array a.size() = " << a.size() << "\n"
    "was not equal to the expected size arrayDim = " << arrayDim << "!"
    );
  return a;
}

inline
RCP<ParameterList> sublist(
  const RCP<ParameterList> &paramList, const std::string& name, bool mustAlreadyExist = false
  )
{
  return rcpWithEmbeddedObjPostDestroy(
    &paramList->sublist(name,mustAlreadyExist), paramList, false );
}

inline
RCP<const ParameterList> sublist(
  const RCP<const ParameterList> &paramList, const std::string& name
  )
{
  return rcpWithEmbeddedObjPostDestroy(
    &paramList->sublist(name), paramList, false );
}
  
inline std::ostream& operator<<(std::ostream& os, const ParameterList& l)
{
  return l.print(os);
}
  
} // end of Teuchos namespace

#endif

---