nojhan/eodev
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Provide eoParser::setORcreateParam to set a paramter in the parser to

Browse source 
a specific value.
This commit is contained in:
kuepper 2005-08-29 07:50:50 +00:00
commit f0fd15f20c
3 changed files with 421 additions and 399 deletions
Download patch file Download diff file Expand all files Collapse all files

467
eo/src/utils/eoParam.h
View file

@ -3,25 +3,25 @@
//-----------------------------------------------------------------------------
// eoParam.h
// (c) Marc Schoenauer, Maarten Keijzer and GeNeura Team, 2000
/*
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 of the License, or (at your option) any later version.
/*
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 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.
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
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
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr
mkeijzer@dhi.dk
*/
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr
mkeijzer@dhi.dk
*/
//-----------------------------------------------------------------------------
#ifndef eoParam_h
@ -43,154 +43,177 @@
#include <vector>
#include <iterator> // for GCC 3.2
#include <stdexcept>
#include <stdexcept>
#include <eoScalarFitness.h> // for specializations
/**
eoParam: Base class for monitoring and parsing parameters
eoParam: Base class for monitoring and parsing parameters
*/
class eoParam
class eoParam
{
public:
/** Empty constructor - called from outside any parser
*/
eoParam ()
: repLongName(""), repDefault(""), repDescription(""),
repShortHand(0), repRequired(false){}
/**
* Construct a Param.
* @param _longName Long name of the argument
* @param _default The default value
* @param _description Description of the parameter. What is useful for.
* @param _shortName Short name of the argument (Optional)
* @param _required If it is a necessary parameter or not
*/
eoParam (std::string _longName, std::string _default,
std::string _description, char _shortName = 0, bool _required = false)
: repLongName(_longName), repDefault(_default),
repDescription(_description ),
repShortHand(_shortName), repRequired( _required) {}
/**
* Virtual destructor is needed.
*/
virtual ~eoParam () {};
/**
* Pure virtual function to get the value out.
*/
virtual std::string getValue ( void ) const = 0;
/** Empty constructor - called from outside any parser */
eoParam ()
: repLongName(""), repDefault(""), repDescription(""),
repShortHand(0), repRequired(false)
{}
/**
* Pure virtual function to set the value
*/
virtual void setValue(std::string _value) = 0 ;
/** Construct a Param.
*
* @param _longName Long name of the argument
* @param _default The default value
* @param _description Description of the parameter. What is useful for.
* @param _shortName Short name of the argument (Optional)
* @param _required If it is a necessary parameter or not
*/
eoParam (std::string _longName, std::string _default,
std::string _description, char _shortName = 0, bool _required = false)
: repLongName(_longName), repDefault(_default),
repDescription(_description ),
repShortHand(_shortName), repRequired( _required)
{}
/**
* Returns the short name.
*/
char shortName ( void ) const { return repShortHand; };
/**
* Returns the long name.
*/
const std::string& longName ( void ) const { return repLongName; };
/**
* Returns the description of the argument
*/
const std::string& description ( void ) const { return repDescription; };
/**
* Returns the default value of the argument
*/
const std::string& defValue ( void ) const { return repDefault; };
/**
* Sets the default value of the argument,
*/
void defValue ( std::string str ) { repDefault = str; };
/**
* ALlows to change the name (see the prefix in eoParser.h)
*/
void setLongName(std::string _longName) { repLongName = _longName;}
/**
* Virtual destructor is needed.
*/
virtual ~eoParam () {};
/**
* Pure virtual function to get the value out.
*/
virtual std::string getValue () const = 0;
/**
* Pure virtual function to set the value
*/
virtual void setValue(const std::string& _value) = 0 ;
/**
* Returns the short name.
*/
char shortName() const { return repShortHand; };
/**
* Returns the long name.
*/
const std::string& longName() const { return repLongName; };
/**
* Returns the description of the argument
*/
const std::string& description() const { return repDescription; };
/**
* Returns the default value of the argument
*/
const std::string& defValue() const { return repDefault; };
/**
* Sets the default value of the argument,
*/
void defValue( const std::string& str ) { repDefault = str; };
/**
* ALlows to change the name (see the prefix in eoParser.h)
*/
void setLongName(std::string _longName) { repLongName = _longName;}
/**
* Returns if required or not.
*/
bool required() const { return repRequired; };
/**
* Returns if required or not.
*/
bool required ( void ) const { return repRequired; };
private:
std::string repLongName;
std::string repDefault;
std::string repDescription;
char repShortHand;
bool repRequired;
char repShortHand;
bool repRequired;
};
/**
eoValueParam<ValueType>: templatized derivation of eoParam. Can be used to contain
any scalar value type. It makes use of std::strstream to get and set values. This
should be changed to std::stringstream when that class is available in g++.
eoValueParam<ValueType>: templatized derivation of eoParam. Can be used to contain
any scalar value type. It makes use of std::strstream to get and set values. This
should be changed to std::stringstream when that class is available in g++.
Note also that there is a template specialization for std::pair<double, double> and
for std::vector<double>. These stream their contents delimited with whitespace.
Note also that there is a template specialization for std::pair<double, double> and
for std::vector<double>. These stream their contents delimited with whitespace.
*/
template <class ValueType>
class eoValueParam : public eoParam
{
public :
/** Construct a Param. */
eoValueParam(void) : eoParam() {}
/**
* Construct a Param.
* @param _defaultValue The default value
* @param _longName Long name of the argument
* @param _description Description of the parameter. What is useful for.
* @param _shortName Short name of the argument (Optional)
* @param _required If it is a necessary parameter or not
*/
eoValueParam (ValueType _defaultValue,
std::string _longName,
std::string _description = "No description",
char _shortHand = 0,
bool _required = false)
: eoParam(_longName, "", _description, _shortHand, _required), repValue(_defaultValue)
{
eoParam::defValue(getValue());
}
/** Construct a Param.
*
* @param _defaultValue The default value
* @param _longName Long name of the argument
* @param _description Description of the parameter. What is useful for.
* @param _shortName Short name of the argument (Optional)
* @param _required If it is a necessary parameter or not
*/
eoValueParam(ValueType _defaultValue,
std::string _longName,
std::string _description = "No description",
char _shortHand = 0,
bool _required = false)
: eoParam(_longName, "", _description, _shortHand, _required),
repValue(_defaultValue)
{
eoParam::defValue(getValue());
}
/** Parameter value
@return parameter value
*/
ValueType& value()
{ return repValue; }
/** Parameter value
@overload
@return parameter value
*/
const ValueType& value() const
{ return repValue; }
ValueType& value() { return repValue; }
ValueType value() const { return repValue; }
std::string getValue(void) const
{
{
#ifdef HAVE_SSTREAM
std::ostringstream os;
os << repValue;
std::ostringstream os;
os << repValue;
#else
char buf[1024];
std::ostrstream os(buf, 1023);
os << repValue;
os << std::ends;
char buf[1024];
std::ostrstream os(buf, 1023);
os << repValue;
os << std::ends;
#endif
return os.str();
}
return os.str();
}
void setValue(std::string _value)
{
void setValue(const std::string& _value)
{
#ifdef HAVE_SSTREAM
std::istringstream is(_value);
std::istringstream is(_value);
#else
std::istrstream is(_value.c_str());
std::istrstream is(_value.c_str());
#endif
is >> repValue;
}
is >> repValue;
}
protected:
//private :
ValueType repValue;
};
@ -198,14 +221,14 @@ public :
Specialization for std::string
*/
template <>
inline std::string eoValueParam<std::string>::getValue(void) const
inline std::string eoValueParam<std::string>::getValue() const
{
return repValue;
return repValue;
}
template <>
inline void eoValueParam<bool>::setValue(std::string _value)
inline void eoValueParam<bool>::setValue(const std::string& _value)
{
if (_value.empty())
{
@ -239,7 +262,7 @@ inline std::string eoValueParam<std::pair<double, double> >::getValue(void) cons
/// Because MSVC does not support partial specialization, the std::pair is a double, not a T
template <>
inline void eoValueParam<std::pair<double, double> >::setValue(std::string _value)
inline void eoValueParam<std::pair<double, double> >::setValue(const std::string& _value)
{
#ifdef HAVE_SSTREAM
std::istringstream is(_value);
@ -264,8 +287,8 @@ inline std::string eoValueParam<std::vector<std::vector<double> > >::getValue(vo
os << repValue.size() << ' ';
for (unsigned i = 0; i < repValue.size(); ++i)
{
os << repValue[i].size() << ' ';
std::copy(repValue[i].begin(), repValue[i].end(), std::ostream_iterator<double>(os, " "));
os << repValue[i].size() << ' ';
std::copy(repValue[i].begin(), repValue[i].end(), std::ostream_iterator<double>(os, " "));
}
#ifndef HAVE_SSTREAM
@ -276,7 +299,7 @@ inline std::string eoValueParam<std::vector<std::vector<double> > >::getValue(vo
/// Because MSVC does not support partial specialization, the std::vector is a std::vector of doubles, not a T
template <>
inline void eoValueParam<std::vector<std::vector<double> > >::setValue(std::string _value)
inline void eoValueParam<std::vector<std::vector<double> > >::setValue(const std::string& _value)
{
#ifdef HAVE_SSTREAM
std::istringstream is(_value);
@ -289,13 +312,13 @@ inline void eoValueParam<std::vector<std::vector<double> > >::setValue(std::stri
for (i = 0; i < repValue.size(); ++i)
{
unsigned sz2;
is >> sz2;
repValue[i].resize(sz2);
for (j = 0; j < sz2; ++j)
{
is >> repValue[i][j];
}
unsigned sz2;
is >> sz2;
repValue[i].resize(sz2);
for (j = 0; j < sz2; ++j)
{
is >> repValue[i][j];
}
}
}
@ -320,7 +343,7 @@ inline std::string eoValueParam<std::vector<double> >::getValue(void) const
/// Because MSVC does not support partial specialization, the std::vector is a double, not a T
template <>
inline void eoValueParam<std::vector<double> >::setValue(std::string _value)
inline void eoValueParam<std::vector<double> >::setValue(const std::string& _value)
{
#ifdef HAVE_SSTREAM
std::istringstream is(_value);
@ -355,7 +378,7 @@ inline std::string eoValueParam<std::vector<eoMinimizingFitness> >::getValue(voi
/// Because MSVC does not support partial specialization, the std::vector is a eoMinimizingFitness, not a T
// NOTE: g++ doesn support it either!!!
template <>
inline void eoValueParam<std::vector<eoMinimizingFitness> >::setValue(std::string _value)
inline void eoValueParam<std::vector<eoMinimizingFitness> >::setValue(const std::string& _value)
{
#ifdef HAVE_SSTREAM
std::istringstream is(_value);
@ -373,41 +396,41 @@ inline void eoValueParam<std::vector<eoMinimizingFitness> >::setValue(std::strin
template <>
inline std::string eoValueParam<std::vector<void*> >::getValue(void) const
{
throw std::runtime_error("I cannot getValue for a std::vector<EOT*>");
return std::string("");
throw std::runtime_error("I cannot getValue for a std::vector<EOT*>");
return std::string("");
}
template <>
inline void eoValueParam<std::vector<void*> >::setValue(std::string)
inline void eoValueParam<std::vector<void*> >::setValue(const std::string&)
{
throw std::runtime_error("I cannot setValue for a std::vector<EOT*>");
return;
throw std::runtime_error("I cannot setValue for a std::vector<EOT*>");
return;
}
/*template <class ContainerType>
class eoContainerParam : public eoParam
{
public :
eoContainerParam (ContainerType& value, std::string _shortName, std::string _longName,
std::string _default,
std::string _description,
bool _required,
bool _change )
: value(_value), eoParam(_shortName, _longName, _description, _default, _required, _change)
{}
class eoContainerParam : public eoParam
{
public :
eoContainerParam (ContainerType& value, std::string _shortName, std::string _longName,
std::string _default,
std::string _description,
bool _required,
bool _change )
: value(_value), eoParam(_shortName, _longName, _description, _default, _required, _change)
{}
// void setValue(const std::string & _value)
// {
// std::istd::stringstream is(_value);
// copy(std::istream_iterator<Container::value_type>(is), std::istream_iterator<Container::value_type>(), back_inserter(value));
// }
// {
// std::istd::stringstream is(_value);
// copy(std::istream_iterator<Container::value_type>(is), std::istream_iterator<Container::value_type>(), back_inserter(value));
// }
private :
ContainerType& value;
};*/
private :
ContainerType& value;
};*/
/**
/**
* Another helper class for parsing parameters like
* Keyword(arg1, arg2, ...)
*
@ -420,65 +443,65 @@ private :
class eoParamParamType : public std::pair<std::string,std::vector<std::string> >
{
public:
eoParamParamType(std::string _value)
{
readFrom(_value);
}
eoParamParamType(std::string _value)
{
readFrom(_value);
}
std::ostream & printOn(std::ostream & _os) const
{
_os << first;
unsigned narg = second.size();
if (!narg)
return _os;
std::ostream & printOn(std::ostream & _os) const
{
_os << first;
unsigned narg = second.size();
if (!narg)
return _os;
// Here, we do have args
_os << "(";
if (narg == 1) // 1 arg only
{
_os << second[0] << ")" ;
return _os;
}
// and here more than 1 arg
for (unsigned i=0; i<narg-1; i++)
_os << second[i] << "," ;
_os << second[narg-1] << ")";
return _os;
}
// Here, we do have args
_os << "(";
if (narg == 1) // 1 arg only
{
_os << second[0] << ")" ;
return _os;
}
// and here more than 1 arg
for (unsigned i=0; i<narg-1; i++)
_os << second[i] << "," ;
_os << second[narg-1] << ")";
return _os;
}
std::istream & readFrom(std::istream & _is)
{
std::string value;
_is >> value;
readFrom(value);
return _is;
}
std::istream & readFrom(std::istream & _is)
{
std::string value;
_is >> value;
readFrom(value);
return _is;
}
void readFrom(std::string & _value)
{
second.resize(0); // just in case
size_t pos = _value.find('(');
if (pos >= _value.size()) // no arguments
{
first = _value;
return;
}
// so here we do have arguments
std::string t = _value.substr(pos+1);// the arguments
_value.resize(pos);
first = _value; // done for the keyword (NOTE: may be empty std::string!)
void readFrom(std::string & _value)
{
second.resize(0); // just in case
size_t pos = _value.find('(');
if (pos >= _value.size()) // no arguments
{
first = _value;
return;
}
// so here we do have arguments
std::string t = _value.substr(pos+1);// the arguments
_value.resize(pos);
first = _value; // done for the keyword (NOTE: may be empty std::string!)
// now all arguments
std::string delim(" (),");
while ( (pos=t.find_first_not_of(delim)) < t.size())
{
size_t posEnd = t.find_first_of(delim, pos);
std::string u = t.substr(pos,posEnd);//(t, pos);
/*u.resize(posEnd - pos);*/
second.push_back(u);
t = t.substr(posEnd+1);
}
}
// now all arguments
std::string delim(" (),");
while ( (pos=t.find_first_not_of(delim)) < t.size())
{
size_t posEnd = t.find_first_of(delim, pos);
std::string u = t.substr(pos,posEnd);//(t, pos);
/*u.resize(posEnd - pos);*/
second.push_back(u);
t = t.substr(posEnd+1);
}
}
};
// at the moment, the following are defined in eoParser.cpp

130
eo/src/utils/eoParser.cpp
View file

@ -3,7 +3,7 @@
//-----------------------------------------------------------------------------
// eoParser.cpp
// (c) Marc Schoenauer, Maarten Keijzer and GeNeura Team, 2000
/*
/*
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
@ -31,7 +31,7 @@
#include <stdexcept>
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <iomanip>
#include <utils/compatibility.h>
@ -49,8 +49,8 @@ std::ostream& printSectionHeader(std::ostream& os, std::string section)
if (section == "")
section = "General";
os << '\n' << setw(10) << "###### " << setw(20) << section << setw(10) << " ######\n";
return os;
os << '\n' << setw(10) << "###### " << setw(20) << section << setw(10) << " ######\n";
return os;
}
eoParameterLoader::~eoParameterLoader()
@ -62,102 +62,62 @@ eoParameterLoader::~eoParameterLoader()
}
eoParser::eoParser ( unsigned _argc, char **_argv , string _programDescription, string _lFileParamName, char _shortHand) :
programName( _argv[0]),
programDescription( _programDescription),
eoParser::eoParser ( unsigned _argc, char **_argv , string _programDescription,
string _lFileParamName, char _shortHand) :
programName(_argv[0]),
programDescription( _programDescription),
needHelp(false, "help", "Prints this message", 'h'),
stopOnUnknownParam(true, "stopOnUnknownParam", "Stop if unkown param entered", '\0')
{
// need to process the param file first
// need to process the param file first
// if we want command-line to have highest priority
unsigned i;
unsigned i;
for (i = 1; i < _argc; ++i)
{
if (_argv[i][0] == '@')
{ // read response file
{
if(_argv[i][0] == '@')
{ // read response file
char *pts = _argv[i]+1; // yes a char*, sorry :-)
ifstream ifs (pts);
ifs.peek(); // check if it exists
if (!ifs)
{
string msg = (string)("Could not open response file: ") + pts;
{
string msg = string("Could not open response file: ") + pts;
throw runtime_error(msg);
}
}
// read - will be overwritten by command-line
readFrom(ifs);
break; // stop reading command line args for '@'
}
}
}
}
// now read arguments on command-line
#ifdef HAVE_SSTREAM
stringstream stream;
#else
strstream stream;
#endif
for (i = 1; i < _argc; ++i)
{
stream << _argv[i] << '\n';
}
readFrom(stream);
processParam(needHelp);
processParam(stopOnUnknownParam);
}
/**
* get a handle on a param from its longName
*
* if not found, returns 0 (null pointer :-)
*
* Not very clean (requires hard-coding of the long name twice!)
* but very useful in many occasions...
*/
eoParam* eoParser::getParamWithLongName(std::string _name)
eoParam * eoParser::getParamWithLongName(const std::string& _name) const
{
typedef std::multimap<std::string, eoParam*> MultiMapType;
typedef MultiMapType::const_iterator It;
for (It p = params.begin(); p != params.end(); ++p)
{
if (p->second->longName() == prefix+_name)
return p->second;
}
return 0;
typedef std::multimap<std::string, eoParam*> MultiMapType;
typedef MultiMapType::const_iterator iter;
std::string search(prefix+_name);
for(iter p = params.begin(); p != params.end(); ++p)
if(p->second->longName() == search)
return p->second;
return 0;
}
/** it seems finally that the easiest use of the above method is
through the following, whose interface is similar to that of the
widely-used createParam
For some (probably very stupid) reason, I failed to put it in
the .cpp. Any hint???
*/
/*
template <class ValueType>
eoValueParam<ValueType>& eoParser::getORcreateParam (
ValueType _defaultValue,
std::string _longName,
std::string _description,
char _shortHand,
std::string _section,
bool _required)
{
eoParam* ptParam = getParamWithLongName(_longName);
if (ptParam) { // found
eoValueParam<ValueType>* ptTypedParam =
dynamic_cast<eoValueParam<ValueType>*>(ptParam);
return *ptTypedParam;
}
// not found -> create it
return createParam (_defaultValue, _longName, _description,
_shortHand, _section, _required);
}
*/
void eoParser::processParam(eoParam& param, std::string section)
{
@ -210,7 +170,7 @@ pair<bool, string> eoParser::getValue(eoParam& _param) const
result.second = it->second;
result.first = true;
return result;
}
}
// else (TODO: check environment, just long names)
return result;
@ -256,7 +216,7 @@ void eoParser::readFrom(istream& is)
{
string::iterator equalLocation = find(str.begin() + 2, str.end(), '=');
string value;
if (equalLocation == str.end())
{ // TODO: it should be the next string
value = "";
@ -306,7 +266,7 @@ void eoParser::printOn(ostream& os) const
printSectionHeader(os, section);
//print every param with its value
for (; p != params.end(); ++p)
for (; p != params.end(); ++p)
{
std::string newSection = p->first;
@ -315,14 +275,14 @@ void eoParser::printOn(ostream& os) const
section = newSection;
printSectionHeader(os, section);
}
eoParam* param = p->second;
if (!isItThere(*param)) // comment out the ones not set by the user
os << "# ";
string str = "--" + param->longName() + "=" + param->getValue();
os.setf(ios_base::left, ios_base::adjustfield);
os << setw(40) << str;
@ -330,7 +290,7 @@ void eoParser::printOn(ostream& os) const
if (param->shortName())
os << '-' << param->shortName() << " : ";
os << param->description();
if (param->required())
{
os << " REQUIRED ";
@ -340,7 +300,7 @@ void eoParser::printOn(ostream& os) const
}
}
void eoParser::printHelp(ostream& os)
void eoParser::printHelp(ostream& os)
{
if (needHelp.value() == false && !messages.empty())
{
@ -355,7 +315,7 @@ void eoParser::printHelp(ostream& os)
// print the usage when calling the program from the command line
os << "Usage: "<< programName<<" [Options]\n";
// only short usage!
os << "Options of the form \"-f[=Value]\" or \"--Name[=value]\"" << endl;
os << "Options of the form \"-f[=Value]\" or \"--Name[=value]\"" << endl;
os << "Where:"<<endl;
@ -368,7 +328,7 @@ void eoParser::printHelp(ostream& os)
printSectionHeader(os, section);
//print every param with its value
for (; p != params.end(); ++p)
for (; p != params.end(); ++p)
{
std::string newSection = p->first;
@ -383,7 +343,7 @@ void eoParser::printHelp(ostream& os)
os << "--" <<p->second->longName() <<":\t"
<< p->second->description() ;
os << "\n" << setw(20) << ( (p->second->required())?"Required":"Optional" );
os <<". By default: "<<p->second->defValue() << '\n';
} // for p
@ -393,10 +353,10 @@ void eoParser::printHelp(ostream& os)
}
bool eoParser::userNeedsHelp(void)
bool eoParser::userNeedsHelp(void)
{
/*
check whether there are long or short names entered
/*
check whether there are long or short names entered
without a corresponding parameter
*/
// first, check if we want to check that !
@ -445,18 +405,18 @@ bool eoParser::userNeedsHelp(void)
}
}
}
return needHelp.value() || !messages.empty();
return needHelp.value() || !messages.empty();
}
///////////////// I put these here at the moment
ostream & operator<<(ostream & _os, const eoParamParamType & _rate)
{
{
_rate.printOn(_os);
return _os;
}
istream & operator>>(istream & _is, eoParamParamType & _rate)
{
{
_rate.readFrom(_is);
return _is;
}

195
eo/src/utils/eoParser.h
View file

@ -3,7 +3,7 @@
//-----------------------------------------------------------------------------
// eoParser.h
// (c) Marc Schoenauer, Maarten Keijzer and GeNeura Team, 2000
/*
/*
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
@ -24,12 +24,13 @@
*/
//-----------------------------------------------------------------------------
/**
CVS Info: $Date: 2004-04-05 15:28:12 $ $Version$ $Author: evomarc $
CVS Info: $Date: 2005-08-29 07:50:50 $ $Version$ $Author: kuepper $
*/
#ifndef eoParser_h
#define eoParser_h
#include <map>
#include <sstream>
#include <string>
#include "eoParam.h"
@ -37,64 +38,68 @@ CVS Info: $Date: 2004-04-05 15:28:12 $ $Version$ $Author: evomarc $
#include "eoPersistent.h"
/**
eoParameterLoader is an abstract class that can be used as a base for your own
eoParameterLoader is an abstract class that can be used as a base for your own
parameter loading and saving. The command line parser eoParser is derived from
this class.
*/
class eoParameterLoader
{
public :
/** Need a virtual destructor */
virtual ~eoParameterLoader();
/**
* processParam is used to register a parameter and set its value if it is known
*
*
* @param param the parameter to process
* @param section the section where this parameter belongs
*/
virtual void processParam(eoParam& param, std::string section = "") = 0;
/**
* checks if _param has been actually entered
*/
virtual bool isItThere(eoParam& _param) const = 0;
/**
* checks if _param has been actually entered
*/
virtual bool isItThere(eoParam& _param) const = 0;
/**
* Construct a Param and sets its value. The loader will own the memory thus created
*
* @param _defaultValue The default value
* @param _longName Long name of the argument
* @param _description Description of the parameter. What is useful for.
* @param _shortName Short name of the argument (Optional)
* @param _section Name of the section where the parameter belongs
* @param _required If it is a necessary parameter or not
*/
/**
* Construct a Param and sets its value. The loader will own the memory thus created
*
* @param _defaultValue The default value
* @param _longName Long name of the argument
* @param _description Description of the parameter. What is useful for.
* @param _shortName Short name of the argument (Optional)
* @param _section Name of the section where the parameter belongs
* @param _required If it is a necessary parameter or not
*/
template <class ValueType>
eoValueParam<ValueType>& createParam
(ValueType _defaultValue,
std::string _longName,
(ValueType _defaultValue,
std::string _longName,
std::string _description,
char _shortHand = 0,
std::string _section = "",
bool _required = false)
{
eoValueParam<ValueType>* p = new eoValueParam<ValueType>(_defaultValue, _longName, _description, _shortHand, _required);
eoValueParam<ValueType>* p = new eoValueParam<ValueType>(_defaultValue,
_longName,
_description,
_shortHand,
_required);
ownedParams.push_back(p);
processParam(*p, _section);
return *p;
}
private :
std::vector<eoParam*> ownedParams;
};
/**
eoParser: command line parser and configuration file reader
This class is persistent, so it can be stored and reloaded to restore
@ -109,6 +114,7 @@ public:
* Constructor
* a complete constructor that reads the command line an optionally reads
* a configuration file.
*
* myEo --param-file=param.rc will then load using the parameter file param.rc
*
@ -118,9 +124,9 @@ public:
* @param _lFileParamName Name of the parameter specifying the configuration file (--param-file)
* @param _shortHand Single charachter shorthand for specifying the configuration file
*/
eoParser ( unsigned _argc, char **_argv , std::string _programDescription = "",
std::string _lFileParamName = "param-file", char _shortHand = 'p');
eoParser ( unsigned _argc, char **_argv , std::string _programDescription = "",
std::string _lFileParamName = "param-file", char _shortHand = 'p');
/**
Processes the parameter and puts it in the appropriate section for readability
*/
@ -129,12 +135,12 @@ public:
void readFrom(std::istream& is);
void printOn(std::ostream& os) const;
/// className for readibility
/// className for readibility
std::string className(void) const { return "Parser"; }
/// true if the user made an error or asked for help
bool userNeedsHelp(void);
bool userNeedsHelp(void);
/**
* Prints an automatic help in the specified output using the information
* provided by parameters
@ -142,79 +148,112 @@ public:
void printHelp(std::ostream& os);
std::string ProgramName() { return programName; }
/**
/**
* checks if _param has been actually entered by the user
*/
virtual bool isItThere(eoParam& _param) const
virtual bool isItThere(eoParam& _param) const
{ return getValue(_param).first; }
/**
* get a handle on a param from its longName
*
* if not found, returns 0 (null pointer :-)
*
* Not very clean (requires hard-coding of the long name twice!)
* but very useful in many occasions...
*/
eoParam* getParamWithLongName(std::string _name);
/**
* get a handle on a param from its longName
*
* if not found, returns 0 (null pointer :-)
*
* Not very clean (requires hard-coding of the long name twice!)
* but very useful in many occasions...
*/
eoParam * getParamWithLongName(const std::string& _name) const;
/** it seems finally that the easiest use of the above method is
through the following, whose interface is similar to that of the
widely-used createParam
For some (probably very stupid) reason, I failed to put it in
the .cpp. Any hint???
*/
/** Get or create parameter
It seems finally that the easiest use of the above method is
through the following, whose interface is similar to that of the
widely-used createParam.
For some (probably very stupid) reason, I failed to put it in the
.cpp. Any hint???
*/
template <class ValueType>
eoValueParam<ValueType>& getORcreateParam
(ValueType _defaultValue,
std::string _longName,
std::string _description,
char _shortHand = 0,
std::string _section = "",
bool _required = false)
{
eoParam* ptParam = getParamWithLongName(_longName);
if (ptParam) { // found
eoValueParam<ValueType>* ptTypedParam =
dynamic_cast<eoValueParam<ValueType>*>(ptParam);
return *ptTypedParam;
}
// not found -> create it
return createParam (_defaultValue, _longName, _description,
_shortHand, _section, _required);
}
eoValueParam<ValueType>& getORcreateParam(ValueType _defaultValue,
std::string _longName,
std::string _description,
char _shortHand = 0,
std::string _section = "",
bool _required = false)
{
eoParam* ptParam = getParamWithLongName(_longName);
if (ptParam) {
// found
eoValueParam<ValueType>* ptTypedParam =
dynamic_cast<eoValueParam<ValueType>*>(ptParam);
return *ptTypedParam;
}
// not found -> create it
return createParam (_defaultValue, _longName, _description,
_shortHand, _section, _required);
}
// /** accessors to the stopOnUnknownParam value */
void setStopOnUnknownParam(bool _b) {stopOnUnknownParam.value()=_b;}
bool getStopOnUnknownParam() {return stopOnUnknownParam.value();}
/** Prefix handling */
void setPrefix(const std:: string & _prefix) {prefix = _prefix;}
/** Make sure parameter has specific value
This requires that operator<< is defined for ValueType.
*/
template <class ValueType>
void setORcreateParam(ValueType _defaultValue, std::string _longName,
std::string _description, char _shortHand = 0,
std::string _section = "", bool _required = false)
{
eoParam *param = getParamWithLongName(_longName);
if(0 == param) {
createParam(_defaultValue, _longName, _description,
_shortHand, _section, _required);
} else {
#ifdef HAVE_SSTREAM
std::ostringstream os;
#else
std::ostrstream os;
#endif
os << _defaultValue;
dynamic_cast<eoValueParam<int> *>(param)->setValue(os.str());
}
}
/** accessors to the stopOnUnknownParam value */
void setStopOnUnknownParam(bool _b) {stopOnUnknownParam.value()=_b;}
bool getStopOnUnknownParam() {return stopOnUnknownParam.value();}
/** Prefix handling */
void setPrefix(const std:: string & _prefix) {prefix = _prefix;}
void resetPrefix() {prefix = "";}
std::string getPrefix() {return prefix;}
private:
void doRegisterParam(eoParam& param) const;
std::pair<bool, std::string> getValue(eoParam& _param) const;
void updateParameters() const;
typedef std::multimap<std::string, eoParam*> MultiMapType;
// used to store all parameters that are processed
MultiMapType params;
std::string programName;
std::string programName;
std::string programDescription;
typedef std::map<char, std::string> ShortNameMapType;
ShortNameMapType shortNameMap;
typedef std::map<std::string, std::string> LongNameMapType;
LongNameMapType longNameMap;