ParametrizableObject Class Reference

#include <ParametrizableObject.hpp>

Inheritance diagram for ParametrizableObject:

Inheritance graph
[legend]

List of all members.

Public Member Functions

void get (IdentifierSet &I)
void reset ()
const ReferenceCounting
< Parameter
get (const char *parameterName) const
 ParametrizableObject ()
 Constructs a ParametrizableObject.
virtual ~ParametrizableObject ()

Protected Member Functions

void add (ReferenceCounting< Parameter > p)
template<typename EnumType>
void get (const char *label, EnumType &e) const
void get (const char *label, real_t &d) const
void get (const char *label, int &i) const
void get (const char *label, std::string &s) const

Private Types

typedef std::map< const char
*, ReferenceCounting
< Parameter >, StringEquality
ParameterList

Private Member Functions

virtual std::ostream & put (std::ostream &os) const =0

Private Attributes

ParameterList __parameters

Friends

std::ostream & operator<< (std::ostream &os, const ParametrizableObject &P)
 Writes the ParametrizableObject.


Detailed Description

This class defines objects that can be parametrized and the default values of parameters.

Author:
Stéphane Del Pino.

Definition at line 42 of file ParametrizableObject.hpp.


Member Typedef Documentation

Definition at line 49 of file ParametrizableObject.hpp.


Constructor & Destructor Documentation

ParametrizableObject::ParametrizableObject (  )  [inline]

Constructs a ParametrizableObject.

Constructs a ParametrizableObject with a given Parameter p and gives the id of the Parametrizable object.

Definition at line 136 of file ParametrizableObject.hpp.

00137   {
00138     ;
00139   }

virtual ParametrizableObject::~ParametrizableObject (  )  [inline, virtual]

Definition at line 141 of file ParametrizableObject.hpp.

00142   {
00143     ;
00144   }


Member Function Documentation

virtual std::ostream& ParametrizableObject::put ( std::ostream &  os  )  const [private, pure virtual]

void ParametrizableObject::get ( IdentifierSet I  )  [inline]

Definition at line 54 of file ParametrizableObject.hpp.

References __parameters.

00055   {
00056     for (ParameterList::iterator i = __parameters.begin();
00057          i != __parameters.end(); ++i)
00058       {
00059         (*(*i).second).get(I);
00060         I.insert((*i).first);
00061       }
00062   }

void ParametrizableObject::add ( ReferenceCounting< Parameter p  )  [inline, protected]

Definition at line 65 of file ParametrizableObject.hpp.

References __parameters.

00066   {
00067     __parameters[(*p).label()] = p;
00068   }

template<typename EnumType>
void ParametrizableObject::get ( const char *  label,
EnumType &  e 
) const [inline, protected]

Definition at line 71 of file ParametrizableObject.hpp.

References Parameter::Enum.

00072   {
00073     ReferenceCounting<Parameter> p = get(label);
00074     if((*p).type() == Parameter::Enum) {
00075       e = dynamic_cast<const EnumParameter<EnumType>&>(*p);
00076       return;
00077     }
00078   }

void ParametrizableObject::get ( const char *  label,
real_t &  d 
) const [inline, protected]

Definition at line 80 of file ParametrizableObject.hpp.

References Parameter::Double.

00081   {
00082     ReferenceCounting<Parameter> p = get(label);
00083     if((*p).type() == Parameter::Double) {
00084       d = dynamic_cast<const DoubleParameter&>(*p);
00085       return;
00086     }      
00087   }

void ParametrizableObject::get ( const char *  label,
int &  i 
) const [inline, protected]

Definition at line 89 of file ParametrizableObject.hpp.

References Parameter::Integer.

00090   {
00091     ReferenceCounting<Parameter> p = get(label);
00092     if((*p).type() == Parameter::Integer) {
00093       i = dynamic_cast<const IntegerParameter&>(*p);
00094       return;
00095     }      
00096   }

void ParametrizableObject::get ( const char *  label,
std::string &  s 
) const [inline, protected]

Definition at line 98 of file ParametrizableObject.hpp.

References Parameter::String.

00099   {
00100     ReferenceCounting<Parameter> p = get(label);
00101     if((*p).type() == Parameter::String) {
00102       s = dynamic_cast<const StringParameter&>(*p);
00103       return;
00104     }      
00105   }

void ParametrizableObject::reset (  )  [inline]

Definition at line 109 of file ParametrizableObject.hpp.

References __parameters.

00110   {
00111     for (ParameterList::iterator i = __parameters.begin();
00112          i != __parameters.end(); ++i) {
00113       (*(*i).second).reset();
00114     }
00115   }

const ReferenceCounting<Parameter> ParametrizableObject::get ( const char *  parameterName  )  const [inline]

Definition at line 117 of file ParametrizableObject.hpp.

References __parameters, ErrorHandler::normal, and stringify().

00118   {
00119     ParameterList::const_iterator i = __parameters.find(parameterName);
00120     if (i != __parameters.end()) {
00121       return (*i).second;
00122     } else {
00123       throw ErrorHandler(__FILE__,__LINE__,
00124                          stringify(parameterName)+" not found",
00125                          ErrorHandler::normal);
00126       return 0;
00127     }
00128   }

Here is the call graph for this function:


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const ParametrizableObject P 
) [friend]

Writes the ParametrizableObject.

Definition at line 22 of file ParametrizableObject.cpp.

00024 {
00025   os  << P.put(os);
00026   return os;
00027 }


Member Data Documentation

Definition at line 51 of file ParametrizableObject.hpp.

Referenced by add(), get(), and reset().


The documentation for this class was generated from the following file:

Generated on Wed Nov 19 00:11:13 2008 for FreeFEM3D (aka ff3d) by  doxygen 1.5.6