In This Package:

ParamValidDataObject.h

Go to the documentation of this file.

//$Id: ParamValidDataObject.h,v 1.11 2008/07/11 16:34:50 marcocle Exp $
#ifndef DETDESC_PARAMVALIDDATAOBJECT_H
#define DETDESC_PARAMVALIDDATAOBJECT_H 1

// Base classes
#include "DetDesc/ValidDataObject.h"

#include "DetDesc/ParamList.h"
#include "DetDesc/ParamException.h"

class ParamValidDataObject : public ValidDataObject {

 public: 
  
  ParamValidDataObject();

  ParamValidDataObject (const ParamValidDataObject& obj);
  
  virtual ~ParamValidDataObject();
  
 public:

  void reset();

 public:

  // Re-implemented from ValidDataObject
  virtual void update ( ValidDataObject& obj );
  
  virtual std::ostream& fillStream( std::ostream& s ) const;

 public:

  bool exists(const std::string &name) const;
  
  virtual const std::type_info &type(const std::string &name) const;

  template <class T>
  inline bool is(const std::string &name) const {
    return type(name) == typeid(T);
  }
  
  bool isVector(const std::string &name) const;

  virtual std::string comment (const std::string &name) const;
  
  virtual void setComment (const std::string &name, const char *comm);
  
  template <class T>
  inline const T &param(const std::string &name) const {
    ParamList::const_iterator i = m_paramList.find(name);
    if ( i == m_paramList.end() ) throw ParamException(name);
    try {
      return i->second-> template get<T>();
    } catch (std::bad_cast) {
      throw ParamException(name,typeid(T),i->second->type());
    }
  }
  
  template <class T>
  inline T &param(const std::string &name) {
    ParamList::iterator i = m_paramList.find(name);
    if ( i == m_paramList.end() ) throw ParamException(name);
    try {
      return i->second-> template get<T>();
    } catch (std::bad_cast) {
      throw ParamException(name,typeid(T),i->second->type());
    }
  }
  
  template <class T>
  inline const std::vector<T> &paramVect(const std::string &name) const {
    return param<std::vector<T> >(name);
  }
  
  template <class T>
  inline std::vector<T> &paramVect(const std::string &name) {
    return param<std::vector<T> >(name);
  }
  
  virtual const std::string &paramAsString (const std::string &name) const;
  
  virtual std::string &paramAsString (const std::string &name);
  
  virtual int paramAsInt (const std::string &name) const;
  
  virtual double paramAsDouble (const std::string &name) const;
  
  virtual const std::vector<std::string> &paramAsStringVect (const std::string &name) const;
  
  virtual std::vector<std::string> &paramAsStringVect (const std::string &name);
  
  virtual const std::vector<int> &paramAsIntVect (const std::string &name) const;
  
  virtual std::vector<int> &paramAsIntVect (const std::string &name);
  
  virtual const std::vector<double> &paramAsDoubleVect (const std::string &name) const;
  
  virtual std::vector<double> &paramAsDoubleVect (const std::string &name);

  virtual std::vector<std::string> paramNames() const;

  virtual std::string printParams() const ;
  
  virtual std::string paramToString(const std::string &name, int precision) const ;
 
public:

  template <class T>
  inline void addParam(const std::string &name, const T &value, const std::string &comment=std::string()){
        m_paramList.add(name,value);
        if (!comment.empty()) {
          m_comments[name] = comment;
        }
  }

  inline void addBasicParam(const std::string &name, const BasicParam *p, const std::string &comment=std::string()){
        m_paramList.addBasicParam(name,p);
        if (!comment.empty()) {
          m_comments[name] = comment;
        }
  }

private:
  
  typedef std::map<std::string,std::string> CommentMap;
  
  ParamList m_paramList;
  CommentMap m_comments;
  
};

#endif // DETDESC_PARAMVALIDDATAOBJECT_H

---