diff --git a/eo/src/utils/eoParam.h b/eo/src/utils/eoParam.h index 75875b9b..7fe537c5 100644 --- a/eo/src/utils/eoParam.h +++ b/eo/src/utils/eoParam.h @@ -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 #include // for GCC 3.2 -#include +#include #include // 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: 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: 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 and - for std::vector. These stream their contents delimited with whitespace. + Note also that there is a template specialization for std::pair and + for std::vector. These stream their contents delimited with whitespace. */ - template 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::getValue(void) const +inline std::string eoValueParam::getValue() const { - return repValue; + return repValue; } template <> -inline void eoValueParam::setValue(std::string _value) +inline void eoValueParam::setValue(const std::string& _value) { if (_value.empty()) { @@ -239,7 +262,7 @@ inline std::string eoValueParam >::getValue(void) cons /// Because MSVC does not support partial specialization, the std::pair is a double, not a T template <> -inline void eoValueParam >::setValue(std::string _value) +inline void eoValueParam >::setValue(const std::string& _value) { #ifdef HAVE_SSTREAM std::istringstream is(_value); @@ -264,8 +287,8 @@ inline std::string eoValueParam > >::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(os, " ")); + os << repValue[i].size() << ' '; + std::copy(repValue[i].begin(), repValue[i].end(), std::ostream_iterator(os, " ")); } #ifndef HAVE_SSTREAM @@ -276,7 +299,7 @@ inline std::string eoValueParam > >::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 > >::setValue(std::string _value) +inline void eoValueParam > >::setValue(const std::string& _value) { #ifdef HAVE_SSTREAM std::istringstream is(_value); @@ -289,13 +312,13 @@ inline void eoValueParam > >::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 >::getValue(void) const /// Because MSVC does not support partial specialization, the std::vector is a double, not a T template <> -inline void eoValueParam >::setValue(std::string _value) +inline void eoValueParam >::setValue(const std::string& _value) { #ifdef HAVE_SSTREAM std::istringstream is(_value); @@ -355,7 +378,7 @@ inline std::string eoValueParam >::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 >::setValue(std::string _value) +inline void eoValueParam >::setValue(const std::string& _value) { #ifdef HAVE_SSTREAM std::istringstream is(_value); @@ -373,41 +396,41 @@ inline void eoValueParam >::setValue(std::strin template <> inline std::string eoValueParam >::getValue(void) const { - throw std::runtime_error("I cannot getValue for a std::vector"); - return std::string(""); + throw std::runtime_error("I cannot getValue for a std::vector"); + return std::string(""); } template <> -inline void eoValueParam >::setValue(std::string) +inline void eoValueParam >::setValue(const std::string&) { - throw std::runtime_error("I cannot setValue for a std::vector"); - return; + throw std::runtime_error("I cannot setValue for a std::vector"); + return; } /*template -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(is), std::istream_iterator(), back_inserter(value)); - // } + // { + // std::istd::stringstream is(_value); + // copy(std::istream_iterator(is), std::istream_iterator(), 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 > { 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> 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 diff --git a/eo/src/utils/eoParser.cpp b/eo/src/utils/eoParser.cpp index 009fd402..518570be 100644 --- a/eo/src/utils/eoParser.cpp +++ b/eo/src/utils/eoParser.cpp @@ -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 #include #include -#include +#include #include @@ -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 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 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 -eoValueParam& 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* ptTypedParam = - dynamic_cast*>(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 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:"<first; @@ -383,7 +343,7 @@ void eoParser::printHelp(ostream& os) os << "--" <second->longName() <<":\t" << p->second->description() ; - + os << "\n" << setw(20) << ( (p->second->required())?"Required":"Optional" ); os <<". By default: "<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; } diff --git a/eo/src/utils/eoParser.h b/eo/src/utils/eoParser.h index e783e62a..2f549d36 100644 --- a/eo/src/utils/eoParser.h +++ b/eo/src/utils/eoParser.h @@ -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 +#include #include #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 eoValueParam& createParam - (ValueType _defaultValue, - std::string _longName, + (ValueType _defaultValue, + std::string _longName, std::string _description, char _shortHand = 0, std::string _section = "", bool _required = false) { - eoValueParam* p = new eoValueParam(_defaultValue, _longName, _description, _shortHand, _required); - + eoValueParam* p = new eoValueParam(_defaultValue, + _longName, + _description, + _shortHand, + _required); ownedParams.push_back(p); - processParam(*p, _section); - return *p; } + private : std::vector 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 - eoValueParam& 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* ptTypedParam = - dynamic_cast*>(ptParam); - return *ptTypedParam; - } - // not found -> create it - return createParam (_defaultValue, _longName, _description, - _shortHand, _section, _required); -} + eoValueParam& 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* ptTypedParam = + dynamic_cast*>(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 + 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 *>(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 getValue(eoParam& _param) const; void updateParameters() const; - + typedef std::multimap MultiMapType; // used to store all parameters that are processed MultiMapType params; - - std::string programName; + + std::string programName; std::string programDescription; typedef std::map ShortNameMapType; ShortNameMapType shortNameMap; - + typedef std::map LongNameMapType; LongNameMapType longNameMap;