fei_ParameterSet.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the 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.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/
 
#ifndef _fei_ParameterSet_hpp_
#define _fei_ParameterSet_hpp_
 
#include "fei_macros.hpp"
#include "fei_Param.hpp"
 
#include <vector>
 
namespace fei {

class ParameterSet {
 public:
  ParameterSet();

  virtual ~ParameterSet();

  void add(const Param& param,
     bool maintain_unique_keys=true);

  const Param* get(const char* name) const;

  int size() const;

  class const_iterator {
  public:
    const_iterator() : paramarray_(NULL),
                       dummyParam_((const char*)NULL, (const char*)NULL),
                       offset_(0) {}

    const_iterator(int offset, std::vector<const Param*>* params)
     :  paramarray_(params), dummyParam_((const char*)NULL, (const char*)NULL),
       offset_(offset)
      {
  if (params != NULL) {
    if (params->empty()) {paramarray_ = NULL; offset_ = 0;}
  }
      }

    ~const_iterator(){}

    const Param& operator*() const
    {
      if (paramarray_ == NULL) return(dummyParam_);
      if (offset_ >= paramarray_->size()) return(dummyParam_);
      return( *((*paramarray_)[offset_]) );
    }

    const_iterator& operator++()
    {
      if (paramarray_ != NULL) {
        if (offset_ < paramarray_->size()) {
          ++offset_;
        }
        if (offset_ == paramarray_->size()) {
          offset_ = 0;
          paramarray_ = NULL;
        }
      }
      return( *this );
    }

    const_iterator& operator=(const const_iterator& src)
    {
      paramarray_ = src.paramarray_;
      offset_ = src.offset_;
      return( *this );
    }

    bool operator==(const const_iterator& rhs)
    {
      return( paramarray_ == rhs.paramarray_ && offset_ == rhs.offset_ );
    }

    bool operator!=(const const_iterator& rhs)
    {
      return( !(*this == rhs) );
    }
 
  private:
    std::vector<const fei::Param*>* paramarray_;
    const fei::Param dummyParam_;
    unsigned offset_;
  };

  const_iterator begin() const;

  const_iterator end() const;

  int getIntParamValue(const char* name,
           int& paramValue) const;

  int getDoubleParamValue(const char* name,
        double& paramValue) const;

  int getStringParamValue(const char* name,
        std::string& paramValue) const;

  int getBoolParamValue(const char* name,
      bool& paramValue) const;

  int getVoidParamValue(const char* name,
      const void*& paramValue) const;
 
 private:
  int findOffset(const fei::Param* param) const;
  int findOffset(const char* name) const;
  std::vector<const Param*>* params_;
};//class ParameterSet
 
}//namespace fei
 
inline
int fei::ParameterSet::findOffset(const char* name) const
{
  if (params_->empty() || name == NULL) return( -1 );
 
  std::vector<const Param*>::const_iterator
    p_iter = params_->begin(),
    p_end = params_->end();
 
  int i = 0;
  for(; p_iter != p_end; ++p_iter, ++i) {
    const Param* prm = *p_iter;
    if (prm->getName() == name) {
      return(i);
    }
  }
  return(-1);
}
 
inline
int fei::ParameterSet::findOffset(const fei::Param* param) const
{
  if (param == NULL) return( -1 );
 
  return( findOffset( param->getName().c_str() ) );
}
 
inline
fei::ParameterSet::const_iterator fei::ParameterSet::begin() const
{
  return( const_iterator(0, params_) );
}
 
inline
fei::ParameterSet::const_iterator fei::ParameterSet::end() const
{
  return( const_iterator(0, NULL) );
}
 
inline
void fei::ParameterSet::add(const fei::Param& param, bool maintain_unique_keys)
{
  int index = findOffset(&param);
  const fei::Param* newparam = new fei::Param(param);
  if (index < 0) {
    params_->push_back(newparam);
  }
  else {
    if (maintain_unique_keys) {
      delete (*params_)[index];
      (*params_)[index] = newparam;
    }
    else {
      params_->push_back(newparam);
    }
  }
}
 
inline
int fei::ParameterSet::size() const
{
  return( params_->size() );
}
 
inline
const fei::Param* fei::ParameterSet::get(const char* name) const
{
  if (params_ == NULL) return(NULL);
 
  int index = findOffset(name);
  if (index < 0) return(NULL);
  return( (*params_)[index] );
}
 
#endif