From ad7f3fdab39de1b370d1076828d182a43f0b6d06 Mon Sep 17 00:00:00 2001 From: mes5k Date: Sun, 26 Sep 2004 23:54:16 +0000 Subject: [PATCH] minor formatting --- include/tclap/Arg.h | 10 +- include/tclap/CmdLine.h | 18 +- include/tclap/CmdLineInterface.h | 104 ++-- include/tclap/MultiArg.h | 829 +++++++++++++++---------------- include/tclap/PrintSensibly.h | 10 +- include/tclap/ValueArg.h | 805 ++++++++++++++++-------------- 6 files changed, 909 insertions(+), 867 deletions(-) diff --git a/include/tclap/Arg.h b/include/tclap/Arg.h index 82370bc..60ca805 100644 --- a/include/tclap/Arg.h +++ b/include/tclap/Arg.h @@ -48,10 +48,7 @@ class Arg /** * Indicates whether the rest of the arguments should be ignored. */ - static bool& ignoreRestRef() { static bool ign = false; return ign; } - - - protected: + static bool& ignoreRestRef() { static bool ign = false; return ign; } /** * The delimiter that separates an argument flag/name from the @@ -59,6 +56,8 @@ class Arg */ static char& delimiterRef() { static char delim = ' '; return delim; } + protected: + /** * The single char flag used to identify the argument. * This value (preceded by a dash {-}), can be used to identify @@ -446,7 +445,8 @@ inline bool Arg::operator==(const Arg& a) // should be overridden inline bool Arg::processArg(int* i, std::vector& args) { - std::cerr << "WARNING: Ignoring unknown argument: " << args[*i] << std::endl; + std::cerr << "WARNING: Ignoring unknown argument: " + << args[*i] << std::endl; return false; } diff --git a/include/tclap/CmdLine.h b/include/tclap/CmdLine.h index 7020499..c47ca48 100644 --- a/include/tclap/CmdLine.h +++ b/include/tclap/CmdLine.h @@ -37,8 +37,6 @@ #include #include #include -#include -#include #include #include @@ -231,7 +229,9 @@ class CmdLine : public CmdLineInterface //Begin CmdLine.cpp /////////////////////////////////////////////////////////////////////////////// -inline CmdLine::CmdLine(const std::string& n, const std::string& m, const std::string& v ) +inline CmdLine::CmdLine(const std::string& n, + const std::string& m, + const std::string& v ) : _progName(n), _message(m), _version(v), @@ -241,7 +241,9 @@ inline CmdLine::CmdLine(const std::string& n, const std::string& m, const std::s _constructor(); } -inline CmdLine::CmdLine(const std::string& m, char delim, const std::string& v ) +inline CmdLine::CmdLine(const std::string& m, + char delim, + const std::string& v ) : _progName("not_set_yet"), _message(m), _version(v), @@ -339,7 +341,8 @@ inline void CmdLine::add( Arg* a ) inline void CmdLine::version(int exitVal) { - std::cout << std::endl << _progName << " version: " << _version << std::endl << std::endl; + std::cout << std::endl << _progName << " version: " + << _version << std::endl << std::endl; exit( exitVal ); } @@ -429,14 +432,15 @@ inline void CmdLine::parse(int argc, char** argv) } catch ( ArgException e ) { std::cerr << "PARSE ERROR: " << e.argId() << std::endl - << " " << e.error() << std::endl << std::endl; + << " " << e.error() << std::endl << std::endl; std::cerr << "Brief USAGE: " << std::endl; _shortUsage( std::cerr ); std::cerr << std::endl << "For complete USAGE and HELP type: " - << std::endl << " " << _progName << " --help" << std::endl << std::endl; + << std::endl << " " << _progName << " --help" + << std::endl << std::endl; exit(1); } diff --git a/include/tclap/CmdLineInterface.h b/include/tclap/CmdLineInterface.h index de70ed5..05f1785 100644 --- a/include/tclap/CmdLineInterface.h +++ b/include/tclap/CmdLineInterface.h @@ -36,64 +36,68 @@ namespace TCLAP { - class Arg; +class Arg; - /** - * The base class that manages the command line definition and passes - * along the parsing to the appropriate Arg classes. - */ - class CmdLineInterface - { - public: - virtual ~CmdLineInterface() {} +/** + * The base class that manages the command line definition and passes + * along the parsing to the appropriate Arg classes. + */ +class CmdLineInterface +{ + public: - /** - * Adds an argument to the list of arguments to be parsed. - * \param a - Argument to be added. - */ - virtual void add( Arg& a )=0; + /** + * Destructor + */ + virtual ~CmdLineInterface() {} - /** - * An alternative add. Functionally identical. - * \param a - Argument to be added. - */ - virtual void add( Arg* a )=0; + /** + * Adds an argument to the list of arguments to be parsed. + * \param a - Argument to be added. + */ + virtual void add( Arg& a )=0; - /** - * Add two Args that will be xor'd. - * If this method is used, add does - * not need to be called. - * \param a - Argument to be added and xor'd. - * \param b - Argument to be added and xor'd. - */ - virtual void xorAdd( Arg& a, Arg& b )=0; + /** + * An alternative add. Functionally identical. + * \param a - Argument to be added. + */ + virtual void add( Arg* a )=0; - /** - * Add a list of Args that will be xor'd. If this method is used, - * add does not need to be called. - * \param xors - List of Args to be added and xor'd. - */ - virtual void xorAdd( std::vector& xors )=0; + /** + * Add two Args that will be xor'd. + * If this method is used, add does + * not need to be called. + * \param a - Argument to be added and xor'd. + * \param b - Argument to be added and xor'd. + */ + virtual void xorAdd( Arg& a, Arg& b )=0; - /** - * Prints the usage to stdout and exits. - * \param exitVal - Value to exit with. - */ - virtual void usage( int exitVal = 0 )=0; + /** + * Add a list of Args that will be xor'd. If this method is used, + * add does not need to be called. + * \param xors - List of Args to be added and xor'd. + */ + virtual void xorAdd( std::vector& xors )=0; - /** - * Prints the version to stdout and exits. - * \param exitVal - Value to exit with. - */ - virtual void version( int exitVal = 0 )=0; + /** + * Prints the usage to stdout and exits. + * \param exitVal - Value to exit with. + */ + virtual void usage( int exitVal = 0 )=0; - /** - * Parses the command line. - * \param argc - Number of arguments. - * \param argv - Array of arguments. - */ - virtual void parse(int argc, char** argv)=0; - }; + /** + * Prints the version to stdout and exits. + * \param exitVal - Value to exit with. + */ + virtual void version( int exitVal = 0 )=0; + + /** + * Parses the command line. + * \param argc - Number of arguments. + * \param argv - Array of arguments. + */ + virtual void parse(int argc, char** argv)=0; +}; } //namespace diff --git a/include/tclap/MultiArg.h b/include/tclap/MultiArg.h index 5125d49..29784fa 100644 --- a/include/tclap/MultiArg.h +++ b/include/tclap/MultiArg.h @@ -1,5 +1,3 @@ -/* -*- Mode: CC; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ - /****************************************************************************** * * file: MultiArg.h @@ -33,500 +31,493 @@ namespace TCLAP { - template class MultiArg; +template class MultiArg; namespace MULTI_ARG_HELPER { - enum Error_e { - EFAIL = 1000, - EMANY - }; +enum Error_e { EFAIL = 1000, EMANY }; - //This class is used to extract a value from an argument. - //It is used because we need a special implementation to - //deal with std::string and making a specialiced function - //puts it in the T segment, thus generating link errors. - //Having a specialiced class makes the symbols weak. - //This is not pretty but I don't know how to make it - //work any other way. - template - class ValueExtractor - { - friend class MultiArg; +/** + * This class is used to extract a value from an argument. + * It is used because we need a special implementation to + * deal with std::string and making a specialiced function + * puts it in the T segment, thus generating link errors. + * Having a specialiced class makes the symbols weak. + * This is not pretty but I don't know how to make it + * work any other way. + */ +template +class ValueExtractor +{ + friend class MultiArg; - private: - std::vector &_values; + private: + + /** + * Reference to the vector of values where the result of the + * extraction will be put. + */ + std::vector &_values; - ValueExtractor(std::vector &values) : _values(values) {} + /** + * Constructor. + * \param values - Where the values extracted will be put. + */ + ValueExtractor(std::vector &values) : _values(values) {} - int extractValue( const std::string& val ) { - T temp; - std::istringstream is(val); - int valuesRead = 0; + /** + * Method that will attempt to parse the input stream for values + * of type T. + * \param val - Where the values parsed will be put. + */ + int extractValue( const std::string& val ) + { + T temp; + std::istringstream is(val); + int valuesRead = 0; - while ( is.good() ) { - if ( is.peek() != EOF ) - is >> temp; - else - break; + while ( is.good() ) + { + if ( is.peek() != EOF ) + is >> temp; + else + break; - valuesRead++; - } + valuesRead++; + } - if ( is.fail() ) - return EFAIL; + if ( is.fail() ) + return EFAIL; - if ( valuesRead > 1 ) - return EMANY; + if ( valuesRead > 1 ) + return EMANY; - _values.push_back(temp); + _values.push_back(temp); - return 0; - } - }; + return 0; + } +}; - /** - * Specialization for string. This is necessary because istringstream - * operator>> is not able to ignore spaces... meaning -x "X Y" will only - * read 'X'... and thus the specialization. - */ - template<> - class ValueExtractor { - friend class MultiArg; - private: +/** + * Specialization for string. This is necessary because istringstream + * operator>> is not able to ignore spaces... meaning -x "X Y" will only + * read 'X'... and thus the specialization. + */ +template<> +class ValueExtractor +{ + friend class MultiArg; + + private: + + /** + * Reference to the vector of strings where the result of the + * extraction will be put. + */ std::vector &_values; + /** + * Constructor. + * \param values - Where the strings extracted will be put. + */ ValueExtractor(std::vector &values) : _values(values) {} - int extractValue( const std::string& val ) { + /** + * Method that will attempt to parse the input stream for values + * of type std::string. + * \param val - Where the values parsed will be put. + */ + int extractValue( const std::string& val ) + { _values.push_back( val ); return 0; } - }; +}; } //namespace MULTI_ARG_HELPER - /** - * An argument that allows multiple values of type T to be specified. Very - * similar to a ValueArg, except a vector of values will be returned - * instead of just one. - */ - template - class MultiArg : public Arg - { +/** + * An argument that allows multiple values of type T to be specified. Very + * similar to a ValueArg, except a vector of values will be returned + * instead of just one. + */ +template +class MultiArg : public Arg +{ protected: - /** - * The list of values parsed from the CmdLine. - */ - std::vector _values; + /** + * The list of values parsed from the CmdLine. + */ + std::vector _values; - /** - * A list of allowed values. - * A list of values allowed for this argument. If the value parsed - * for this arg is not found in this list, then an exception is - * thrown. If the list is empty, then any value is allowed. - */ - std::vector _allowed; + /** + * A list of allowed values. + * A list of values allowed for this argument. If the value parsed + * for this arg is not found in this list, then an exception is + * thrown. If the list is empty, then any value is allowed. + */ + std::vector _allowed; - /** - * The description of type T to be used in the usage. - */ - std::string _typeDesc; + /** + * The description of type T to be used in the usage. + */ + std::string _typeDesc; - /** - * Extracts the value from the string. - * Attempts to parse string as type T, if this fails an exception - * is thrown. - * \param val - The string to be read. - */ - void _extractValue( const std::string& val ) { - MULTI_ARG_HELPER::ValueExtractor ve(_values); - - int err = ve.extractValue(val); - if(err == MULTI_ARG_HELPER::EFAIL) - throw( ArgException("Couldn't read argument value " - "from string '" + - val + "'", toString() ) ); - if(err == MULTI_ARG_HELPER::EMANY) - throw( ArgException("More than one valid value " - "parsed from string '" + - val + "'", toString() ) ); - _checkAllowed( val ); - } - + /** + * Extracts the value from the string. + * Attempts to parse string as type T, if this fails an exception + * is thrown. + * \param val - The string to be read. + */ + void _extractValue( const std::string& val ); - /** - * Checks to see if parsed value is in allowed list. - * \param val - value parsed (only used in output). - */ - void _checkAllowed( const std::string& val ); + /** + * Checks to see if parsed value is in allowed list. + * \param val - value parsed (only used in output). + */ + void _checkAllowed( const std::string& val ); public: - /** - * Constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param typeDesc - A short, human readable description of the - * type that this object expects. This is used in the generation - * of the USAGE statement. The goal is to be helpful to the end user - * of the program. - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - MultiArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::string& typeDesc, - Visitor* v = NULL); + /** + * Constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param typeDesc - A short, human readable description of the + * type that this object expects. This is used in the generation + * of the USAGE statement. The goal is to be helpful to the end user + * of the program. + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + MultiArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::string& typeDesc, + Visitor* v = NULL); - /** - * Constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param typeDesc - A short, human readable description of the - * type that this object expects. This is used in the generation - * of the USAGE statement. The goal is to be helpful to the end user - * of the program. - * \param parser - A CmdLine parser object to add this Arg to - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - MultiArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::string& typeDesc, - CmdLineInterface& parser, - Visitor* v = NULL ); - /** - * Constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param allowed - A vector of type T that where the values in the - * vector are the only values allowed for the arg. - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - MultiArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::vector& allowed, - Visitor* v = NULL ); + /** + * Constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param typeDesc - A short, human readable description of the + * type that this object expects. This is used in the generation + * of the USAGE statement. The goal is to be helpful to the end user + * of the program. + * \param parser - A CmdLine parser object to add this Arg to + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + MultiArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::string& typeDesc, + CmdLineInterface& parser, + Visitor* v = NULL ); + + /** + * Constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param allowed - A vector of type T that where the values in the + * vector are the only values allowed for the arg. + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + MultiArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::vector& allowed, + Visitor* v = NULL ); - /** - * Constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param allowed - A vector of type T that where the values in the - * vector are the only values allowed for the arg. - * \param parser - A CmdLine parser object to add this Arg to - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - MultiArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::vector& allowed, - CmdLineInterface& parser, - Visitor* v = NULL ); + /** + * Constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param allowed - A vector of type T that where the values in the + * vector are the only values allowed for the arg. + * \param parser - A CmdLine parser object to add this Arg to + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + MultiArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::vector& allowed, + CmdLineInterface& parser, + Visitor* v = NULL ); - /** - * Handles the processing of the argument. - * This re-implements the Arg version of this method to set the - * _value of the argument appropriately. It knows the difference - * between labeled and unlabeled. - * \param i - Pointer the the current argument in the list. - * \param args - Mutable list of strings. Passed from main(). - */ - virtual bool processArg(int* i, std::vector& args); + /** + * Handles the processing of the argument. + * This re-implements the Arg version of this method to set the + * _value of the argument appropriately. It knows the difference + * between labeled and unlabeled. + * \param i - Pointer the the current argument in the list. + * \param args - Mutable list of strings. Passed from main(). + */ + virtual bool processArg(int* i, std::vector& args); - /** - * Returns a vector of type T containing the values parsed from - * the command line. - */ - const std::vector& getValue(); + /** + * Returns a vector of type T containing the values parsed from + * the command line. + */ + const std::vector& getValue(); - /** - * Returns the a short id string. Used in the usage. - * \param val - value to be used. - */ - virtual std::string shortID(const std::string& val="val") const; + /** + * Returns the a short id string. Used in the usage. + * \param val - value to be used. + */ + virtual std::string shortID(const std::string& val="val") const; - /** - * Returns the a long id string. Used in the usage. - * \param val - value to be used. - */ - virtual std::string longID(const std::string& val="val") const; + /** + * Returns the a long id string. Used in the usage. + * \param val - value to be used. + */ + virtual std::string longID(const std::string& val="val") const; - /** - * Once we've matched the first value, then the arg is no longer - * required. - */ - virtual bool isRequired() const; + /** + * Once we've matched the first value, then the arg is no longer + * required. + */ + virtual bool isRequired() const; private: - /** - * Common initialization code for constructors with allowed vectors. - */ - void allowedInit(); - }; + /** + * Common initialization code for constructors with allowed vectors. + */ + void allowedInit(); +}; - /** - * - */ - template - void MultiArg::allowedInit() - { - for ( unsigned int i = 0; i < _allowed.size(); i++ ) - { - std::ostringstream os; - os << _allowed[i]; +/** + * + */ +template +void MultiArg::allowedInit() +{ + for ( unsigned int i = 0; i < _allowed.size(); i++ ) + { + std::ostringstream os; + os << _allowed[i]; - std::string temp( os.str() ); + std::string temp( os.str() ); - if ( i > 0 ) + if ( i > 0 ) _typeDesc += "|"; - _typeDesc += temp; - } - } + + _typeDesc += temp; + } +} - /** - * - */ - template - MultiArg::MultiArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::string& typeDesc, - Visitor* v) - : Arg( flag, name, desc, req, true, v ), - _typeDesc( typeDesc ) - { } +/** + * + */ +template +MultiArg::MultiArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::string& typeDesc, + Visitor* v) +: Arg( flag, name, desc, req, true, v ), + _typeDesc( typeDesc ) +{ } - template - MultiArg::MultiArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::string& typeDesc, - CmdLineInterface& parser, - Visitor* v) - : Arg( flag, name, desc, req, true, v ), - _typeDesc( typeDesc ) - { - parser.add( this ); - } +template +MultiArg::MultiArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::string& typeDesc, + CmdLineInterface& parser, + Visitor* v) +: Arg( flag, name, desc, req, true, v ), + _typeDesc( typeDesc ) +{ + parser.add( this ); +} - /** - * - */ - template - MultiArg::MultiArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::vector& allowed, - Visitor* v) - : Arg( flag, name, desc, req, true, v ), - _allowed( allowed ) - { - allowedInit(); - } +/** + * + */ +template +MultiArg::MultiArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::vector& allowed, + Visitor* v) +: Arg( flag, name, desc, req, true, v ), + _allowed( allowed ) +{ + allowedInit(); +} - template - MultiArg::MultiArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - const std::vector& allowed, - CmdLineInterface& parser, - Visitor* v) - : Arg( flag, name, desc, req, true, v ), - _allowed( allowed ) - { - allowedInit(); - parser.add( this ); - } +template +MultiArg::MultiArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + const std::vector& allowed, + CmdLineInterface& parser, + Visitor* v) +: Arg( flag, name, desc, req, true, v ), + _allowed( allowed ) +{ + allowedInit(); + parser.add( this ); +} - /** - * - */ - template - const std::vector& MultiArg::getValue() { return _values; } +/** + * + */ +template +const std::vector& MultiArg::getValue() { return _values; } - /** - * - */ - template - bool MultiArg::processArg(int *i, std::vector& args) - { - if ( _ignoreable && Arg::ignoreRest() ) +/** + * + */ +template +bool MultiArg::processArg(int *i, std::vector& args) +{ + if ( _ignoreable && Arg::ignoreRest() ) return false; - if ( _hasBlanks( args[*i] ) ) + if ( _hasBlanks( args[*i] ) ) return false; - std::string flag = args[*i]; - std::string value = ""; + std::string flag = args[*i]; + std::string value = ""; - trimFlag( flag, value ); + trimFlag( flag, value ); - if ( argMatches( flag ) ) - { - if ( Arg::delimiter() != ' ' && value == "" ) + if ( argMatches( flag ) ) + { + if ( Arg::delimiter() != ' ' && value == "" ) throw( ArgException( "Couldn't find delimiter for this argument!", - toString() ) ); + toString() ) ); - if ( value == "" ) - { - (*i)++; - if ( (unsigned int)*i < args.size() ) + if ( value == "" ) + { + (*i)++; + if ( (unsigned int)*i < args.size() ) _extractValue( args[*i] ); - else + else throw( ArgException("Missing a value for this argument!", - toString() ) ); - } - else + toString() ) ); + } + else _extractValue( value ); - _checkWithVisitor(); - return true; - } - else + _checkWithVisitor(); + + return true; + } + else return false; - } +} - /* - template - void MultiArg::_extractValue( const std::string& val ) - { - T temp; - std::istringstream is(val); - - int valuesRead = 0; - while ( is.good() ) - { - if ( is.peek() != EOF ) - is >> temp; - else - break; - - valuesRead++; - } - - if ( is.fail() ) - throw( ArgException("Couldn't read argument value from string '" + - val + "'", toString() ) ); - - if ( valuesRead > 1 ) - throw( ArgException("More than one valid value parsed from string '" + - val + "'", toString() ) ); - - - _values.push_back(temp); - - _checkAllowed( val ); - - } - */ - - /** - * Specialization to handle strings with spaces in them. This is needed - * because there is no way to tell operator>> to ignore spaces. - * - template<> - void MultiArg::_extractValue( const std::string& val ) - { - _values.push_back( val ); - - _checkAllowed( val ); - } - */ - /** - * Checks to see if the value parsed is in the allowed list. - */ - template - void MultiArg::_checkAllowed( const std::string& val ) - { - if ( _allowed.size() > 0 ) +/** + * Checks to see if the value parsed is in the allowed list. + */ +template +void MultiArg::_checkAllowed( const std::string& val ) +{ + if ( _allowed.size() > 0 ) if ( find(_allowed.begin(),_allowed.end(),_values.back()) - == _allowed.end() ) - throw( ArgException( "Couldn't find '" + val + - "' in allowed list.", toString() ) ); - } + == _allowed.end() ) + throw( ArgException( "Couldn't find '" + val + + "' in allowed list.", toString() ) ); +} - /** - * - */ - template - std::string MultiArg::shortID(const std::string& val) const - { - std::string id = Arg::shortID(_typeDesc) + " ... "; +/** + * + */ +template +std::string MultiArg::shortID(const std::string& val) const +{ + std::string id = Arg::shortID(_typeDesc) + " ... "; - return id; - } + return id; +} - /** - * - */ - template - std::string MultiArg::longID(const std::string& val) const - { - std::string id = Arg::longID(_typeDesc) + " (accepted multiple times)"; +/** + * + */ +template +std::string MultiArg::longID(const std::string& val) const +{ + std::string id = Arg::longID(_typeDesc) + " (accepted multiple times)"; - return id; - } + return id; +} - /** - * Once we've matched the first value, then the arg is no longer - * required. - */ - template - bool MultiArg::isRequired() const - { - if ( _required ) - { - if ( _values.size() > 1 ) +/** + * Once we've matched the first value, then the arg is no longer + * required. + */ +template +bool MultiArg::isRequired() const +{ + if ( _required ) + { + if ( _values.size() > 1 ) return false; - else + else return true; - } - else + } + else return false; - } - } +template +void MultiArg::_extractValue( const std::string& val ) +{ + MULTI_ARG_HELPER::ValueExtractor ve(_values); + + int err = ve.extractValue(val); + + if ( err == MULTI_ARG_HELPER::EFAIL ) + throw( ArgException("Couldn't read argument value " + "from string '" + val + "'", toString() ) ); + + if(err == MULTI_ARG_HELPER::EMANY) + throw( ArgException("More than one valid value " + "parsed from string '" + val + "'", toString() ) ); + _checkAllowed( val ); +} + + +} // namespace TCLAP + #endif diff --git a/include/tclap/PrintSensibly.h b/include/tclap/PrintSensibly.h index 7a904f7..ec33c30 100644 --- a/include/tclap/PrintSensibly.h +++ b/include/tclap/PrintSensibly.h @@ -39,11 +39,11 @@ namespace TCLAP { * \param secondLineOffset - The number of spaces to indent the second * and all subsequent lines in addition to indentSpaces. */ - inline void spacePrint( std::ostream& os, - const std::string& s, - int maxWidth, - int indentSpaces=0, - int secondLineOffset=0 ) +inline void spacePrint( std::ostream& os, + const std::string& s, + int maxWidth, + int indentSpaces=0, + int secondLineOffset=0 ) { int len = (int)(s.length()); diff --git a/include/tclap/ValueArg.h b/include/tclap/ValueArg.h index e2cb5f4..21cb283 100644 --- a/include/tclap/ValueArg.h +++ b/include/tclap/ValueArg.h @@ -1,5 +1,3 @@ -/* -*- Mode: CC; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ - /****************************************************************************** * * file: ValueArg.h @@ -33,35 +31,54 @@ namespace TCLAP { - template class ValueArg; +template class ValueArg; namespace VALUE_ARG_HELPER { - enum Error_e { - EFAIL = 1000, - EMANY - }; +enum Error_e { EFAIL = 1000, EMANY }; - //This class is used to extract a value from an argument. - //It is used because we need a special implementation to - //deal with std::string and making a specialiced function - //puts it in the T segment, thus generating link errors. - //Having a specialiced class makes the symbols weak. - //This is not pretty but I don't know how to make it - //work any other way. - template class ValueExtractor { - - friend class ValueArg; - private: +/** + * This class is used to extract a value from an argument. + * It is used because we need a special implementation to + * deal with std::string and making a specialiced function + * puts it in the T segment, thus generating link errors. + * Having a specialiced class makes the symbols weak. + * This is not pretty but I don't know how to make it + * work any other way. + */ +template class ValueExtractor +{ + /** + * + */ + friend class ValueArg; + + private: + + /** + * Reference to the value where the result of the extraction will + * be put. + */ T &_value; - ValueExtractor(T &value) : _value(value) {} + /** + * Constructor. + * \param value - Where the value extracted will be put. + */ + ValueExtractor(T &value) : _value(value) { } - int extractValue( const std::string& val ) { + /** + * Method that will attempt to parse the input stream for a value + * of type T. + * \param val - Where the value parsed will be put. + */ + int extractValue( const std::string& val ) + { std::istringstream is(val); int valuesRead = 0; - while ( is.good() ) { + while ( is.good() ) + { if ( is.peek() != EOF ) is >> _value; else @@ -78,422 +95,448 @@ namespace VALUE_ARG_HELPER { return 0; } - }; +}; - /** - * Specialization for string. This is necessary because istringstream - * operator>> is not able to ignore spaces... meaning -x "X Y" will only - * read 'X'... and thus the specialization. - */ - template<> class ValueExtractor { - - friend class ValueArg; - private: +/** + * Specialization for string. This is necessary because istringstream + * operator>> is not able to ignore spaces... meaning -x "X Y" will only + * read 'X'... and thus the specialization. + */ +template<> class ValueExtractor +{ + /** + * + */ + friend class ValueArg; + + private: + + /** + * Reference to the value where the result of the extraction will + * be put. + */ std::string &_value; + /** + * Constructor. + * \param value - Where the value extracted will be put. + */ ValueExtractor(std::string &value) : _value(value) {} - int extractValue( const std::string& val ) { + /** + * Method that will attempt to parse the input stream for a value + * of type std::string. + * \param val - Where the string parsed will be put. + */ + int extractValue( const std::string& val ) + { _value = val; return 0; } - }; +}; } //namespace VALUE_ARG_HELPER - /** - * The basic labeled argument that parses a value. - * This is a template class, which means the type T defines the type - * that a given object will attempt to parse when the flag/name is matched - * on the command line. While there is nothing stopping you from creating - * an unflagged ValueArg, it is unwise and would cause significant problems. - * Instead use an UnlabeledValueArg. - */ - template - class ValueArg : public Arg - { - protected: +/** + * The basic labeled argument that parses a value. + * This is a template class, which means the type T defines the type + * that a given object will attempt to parse when the flag/name is matched + * on the command line. While there is nothing stopping you from creating + * an unflagged ValueArg, it is unwise and would cause significant problems. + * Instead use an UnlabeledValueArg. + */ +template +class ValueArg : public Arg +{ + protected: - /** - * The value parsed from the command line. - * Can be of any type, as long as the >> operator for the type - * is defined. - */ - T _value; + /** + * The value parsed from the command line. + * Can be of any type, as long as the >> operator for the type + * is defined. + */ + T _value; - /** - * A list of allowed values. - * A list of values allowed for this argument. If the value parsed - * for this arg is not found in this list, then an exception is - * thrown. If the list is empty, then any value is allowed. - */ - std::vector _allowed; + /** + * A list of allowed values. + * A list of values allowed for this argument. If the value parsed + * for this arg is not found in this list, then an exception is + * thrown. If the list is empty, then any value is allowed. + */ + std::vector _allowed; - /** - * A human readable description of the type to be parsed. - * This is a hack, plain and simple. Ideally we would use RTTI to - * return the name of type T, but until there is some sort of - * consistent support for human readable names, we are left to our - * own devices. - */ - std::string _typeDesc; + /** + * A human readable description of the type to be parsed. + * This is a hack, plain and simple. Ideally we would use RTTI to + * return the name of type T, but until there is some sort of + * consistent support for human readable names, we are left to our + * own devices. + */ + std::string _typeDesc; - /** - * Extracts the value from the string. - * Attempts to parse string as type T, if this fails an exception - * is thrown. - * \param val - value to be parsed. - */ - void _extractValue( const std::string& val ) { - VALUE_ARG_HELPER::ValueExtractor ve(_value); + /** + * Extracts the value from the string. + * Attempts to parse string as type T, if this fails an exception + * is thrown. + * \param val - value to be parsed. + */ + void _extractValue( const std::string& val ); - int err = ve.extractValue(val); - if(err == VALUE_ARG_HELPER::EFAIL) - throw( ArgException("Couldn't read argument value from string '" + - val + "'", toString() ) ); - if(err == VALUE_ARG_HELPER::EMANY) - throw( ArgException("More than one valid value parsed from string '" + - val + "'", toString() ) ); - - _checkAllowed( val ); - } - - /** - * Checks to see if parsed value is in allowed list. - * \param val - value parsed (only used in output). - */ - void _checkAllowed( const std::string& val ); + /** + * Checks to see if parsed value is in allowed list. + * \param val - value parsed (only used in output). + */ + void _checkAllowed( const std::string& val ); public: - /** - * Labeled ValueArg constructor. - * You could conceivably call this constructor with a blank flag, - * but that would make you a bad person. It would also cause - * an exception to be thrown. If you want an unlabeled argument, - * use the other constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param value - The default value assigned to this argument if it - * is not present on the command line. - * \param typeDesc - A short, human readable description of the - * type that this object expects. This is used in the generation - * of the USAGE statement. The goal is to be helpful to the end user - * of the program. - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - ValueArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T value, - const std::string& typeDesc, - Visitor* v = NULL); + /** + * Labeled ValueArg constructor. + * You could conceivably call this constructor with a blank flag, + * but that would make you a bad person. It would also cause + * an exception to be thrown. If you want an unlabeled argument, + * use the other constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param value - The default value assigned to this argument if it + * is not present on the command line. + * \param typeDesc - A short, human readable description of the + * type that this object expects. This is used in the generation + * of the USAGE statement. The goal is to be helpful to the end user + * of the program. + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + ValueArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T value, + const std::string& typeDesc, + Visitor* v = NULL); - /** - * Labeled ValueArg constructor. - * You could conceivably call this constructor with a blank flag, - * but that would make you a bad person. It would also cause - * an exception to be thrown. If you want an unlabeled argument, - * use the other constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param value - The default value assigned to this argument if it - * is not present on the command line. - * \param typeDesc - A short, human readable description of the - * type that this object expects. This is used in the generation - * of the USAGE statement. The goal is to be helpful to the end user - * of the program. - * \param parser - A CmdLine parser object to add this Arg to - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - ValueArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T value, - const std::string& typeDesc, - CmdLineInterface& parser, - Visitor* v = NULL ); - - /** - * Labeled ValueArg constructor. - * You could conceivably call this constructor with a blank flag, - * but that would make you a bad person. It would also cause - * an exception to be thrown. If you want an unlabeled argument, - * use the other constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param value - The default value assigned to this argument if it - * is not present on the command line. - * \param allowed - A vector of type T that where the values in the - * vector are the only values allowed for the arg. - * \param parser - A CmdLine parser object to add this Arg to. - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - ValueArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T value, - const std::vector& allowed, - CmdLineInterface& parser, - Visitor* v = NULL ); - - /** - * Labeled ValueArg constructor. - * You could conceivably call this constructor with a blank flag, - * but that would make you a bad person. It would also cause - * an exception to be thrown. If you want an unlabeled argument, - * use the other constructor. - * \param flag - The one character flag that identifies this - * argument on the command line. - * \param name - A one word name for the argument. Can be - * used as a long flag on the command line. - * \param desc - A description of what the argument is for or - * does. - * \param req - Whether the argument is required on the command - * line. - * \param value - The default value assigned to this argument if it - * is not present on the command line. - * \param allowed - A vector of type T that where the values in the - * vector are the only values allowed for the arg. - * \param v - An optional visitor. You probably should not - * use this unless you have a very good reason. - */ - ValueArg( const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T value, - const std::vector& allowed, - Visitor* v = NULL ); + /** + * Labeled ValueArg constructor. + * You could conceivably call this constructor with a blank flag, + * but that would make you a bad person. It would also cause + * an exception to be thrown. If you want an unlabeled argument, + * use the other constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param value - The default value assigned to this argument if it + * is not present on the command line. + * \param typeDesc - A short, human readable description of the + * type that this object expects. This is used in the generation + * of the USAGE statement. The goal is to be helpful to the end user + * of the program. + * \param parser - A CmdLine parser object to add this Arg to + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + ValueArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T value, + const std::string& typeDesc, + CmdLineInterface& parser, + Visitor* v = NULL ); + + /** + * Labeled ValueArg constructor. + * You could conceivably call this constructor with a blank flag, + * but that would make you a bad person. It would also cause + * an exception to be thrown. If you want an unlabeled argument, + * use the other constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param value - The default value assigned to this argument if it + * is not present on the command line. + * \param allowed - A vector of type T that where the values in the + * vector are the only values allowed for the arg. + * \param parser - A CmdLine parser object to add this Arg to. + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + ValueArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T value, + const std::vector& allowed, + CmdLineInterface& parser, + Visitor* v = NULL ); + + /** + * Labeled ValueArg constructor. + * You could conceivably call this constructor with a blank flag, + * but that would make you a bad person. It would also cause + * an exception to be thrown. If you want an unlabeled argument, + * use the other constructor. + * \param flag - The one character flag that identifies this + * argument on the command line. + * \param name - A one word name for the argument. Can be + * used as a long flag on the command line. + * \param desc - A description of what the argument is for or + * does. + * \param req - Whether the argument is required on the command + * line. + * \param value - The default value assigned to this argument if it + * is not present on the command line. + * \param allowed - A vector of type T that where the values in the + * vector are the only values allowed for the arg. + * \param v - An optional visitor. You probably should not + * use this unless you have a very good reason. + */ + ValueArg( const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T value, + const std::vector& allowed, + Visitor* v = NULL ); - /** - * Handles the processing of the argument. - * This re-implements the Arg version of this method to set the - * _value of the argument appropriately. It knows the difference - * between labeled and unlabeled. - * \param i - Pointer the the current argument in the list. - * \param args - Mutable list of strings. Passed - * in from main(). - */ - virtual bool processArg(int* i, std::vector& args); + /** + * Handles the processing of the argument. + * This re-implements the Arg version of this method to set the + * _value of the argument appropriately. It knows the difference + * between labeled and unlabeled. + * \param i - Pointer the the current argument in the list. + * \param args - Mutable list of strings. Passed + * in from main(). + */ + virtual bool processArg(int* i, std::vector& args); - /** - * Returns the value of the argument. - */ - T& getValue() ; + /** + * Returns the value of the argument. + */ + T& getValue() ; - /** - * Specialization of shortID. - * \param val - value to be used. - */ - virtual std::string shortID(const std::string& val = "val") const; + /** + * Specialization of shortID. + * \param val - value to be used. + */ + virtual std::string shortID(const std::string& val = "val") const; - /** - * Specialization of longID. - * \param val - value to be used. - */ - virtual std::string longID(const std::string& val = "val") const; + /** + * Specialization of longID. + * \param val - value to be used. + */ + virtual std::string longID(const std::string& val = "val") const; private: - /** - * Common initialization code for constructors with allowed vectors. - */ - void allowedInit(); + /** + * Common initialization code for constructors with allowed vectors. + */ + void allowedInit(); - }; +}; - template - void ValueArg::allowedInit() - { - for ( unsigned int i = 0; i < _allowed.size(); i++ ) - { - std::ostringstream os; - os << _allowed[i]; +template +void ValueArg::allowedInit() +{ + for ( unsigned int i = 0; i < _allowed.size(); i++ ) + { + std::ostringstream os; + os << _allowed[i]; - std::string temp( os.str() ); + std::string temp( os.str() ); - if ( i > 0 ) + if ( i > 0 ) _typeDesc += "|"; - _typeDesc += temp; - } - } + _typeDesc += temp; + } +} - /** - * Constructor implementation. - */ - template - ValueArg::ValueArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T val, - const std::string& typeDesc, - Visitor* v) - : Arg(flag, name, desc, req, true, v), - _value( val ), - _typeDesc( typeDesc ) - { } +/** + * Constructor implementation. + */ +template +ValueArg::ValueArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T val, + const std::string& typeDesc, + Visitor* v) +: Arg(flag, name, desc, req, true, v), + _value( val ), + _typeDesc( typeDesc ) +{ } - template - ValueArg::ValueArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T val, - const std::string& typeDesc, - CmdLineInterface& parser, - Visitor* v) - : Arg(flag, name, desc, req, true, v), - _value( val ), - _typeDesc( typeDesc ) - { - parser.add( this ); - } +template +ValueArg::ValueArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T val, + const std::string& typeDesc, + CmdLineInterface& parser, + Visitor* v) +: Arg(flag, name, desc, req, true, v), + _value( val ), + _typeDesc( typeDesc ) +{ + parser.add( this ); +} - /** - * Constructor with allowed list. - */ - template - ValueArg::ValueArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T val, - const std::vector& allowed, - Visitor* v) - : Arg(flag, name, desc, req, true, v), - _value( val ), - _allowed( allowed ) - { - allowedInit(); - } +/** + * Constructor with allowed list. + */ +template +ValueArg::ValueArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T val, + const std::vector& allowed, + Visitor* v) +: Arg(flag, name, desc, req, true, v), + _value( val ), + _allowed( allowed ) +{ + allowedInit(); +} - template - ValueArg::ValueArg(const std::string& flag, - const std::string& name, - const std::string& desc, - bool req, - T val, - const std::vector& allowed, - CmdLineInterface& parser, - Visitor* v) - : Arg(flag, name, desc, req, true, v), - _value( val ), - _allowed( allowed ) - { - allowedInit(); - parser.add( this ); - } +template +ValueArg::ValueArg(const std::string& flag, + const std::string& name, + const std::string& desc, + bool req, + T val, + const std::vector& allowed, + CmdLineInterface& parser, + Visitor* v) +: Arg(flag, name, desc, req, true, v), +_value( val ), +_allowed( allowed ) +{ + allowedInit(); + parser.add( this ); +} - /** - * Implementation of getValue(). - */ - template - T& ValueArg::getValue() { return _value; } +/** + * Implementation of getValue(). + */ +template +T& ValueArg::getValue() { return _value; } - /** - * Implementation of processArg(). - */ - template - bool ValueArg::processArg(int *i, std::vector& args) - { - if ( _ignoreable && Arg::ignoreRest() ) +/** + * Implementation of processArg(). + */ +template +bool ValueArg::processArg(int *i, std::vector& args) +{ + if ( _ignoreable && Arg::ignoreRest() ) return false; - if ( _hasBlanks( args[*i] ) ) + if ( _hasBlanks( args[*i] ) ) return false; - std::string flag = args[*i]; + std::string flag = args[*i]; - std::string value = ""; - trimFlag( flag, value ); + std::string value = ""; + trimFlag( flag, value ); - if ( argMatches( flag ) ) - { - if ( _alreadySet ) + if ( argMatches( flag ) ) + { + if ( _alreadySet ) throw( ArgException("Argument already set!", toString()) ); - if ( Arg::delimiter() != ' ' && value == "" ) + if ( Arg::delimiter() != ' ' && value == "" ) throw( ArgException( "Couldn't find delimiter for this argument!", - toString() ) ); + toString() ) ); - if ( value == "" ) - { - (*i)++; - if ( (unsigned int)*i < args.size() ) + if ( value == "" ) + { + (*i)++; + if ( (unsigned int)*i < args.size() ) _extractValue( args[*i] ); - else + else throw( ArgException("Missing a value for this argument!", toString() ) ); - } - else + } + else _extractValue( value ); - _alreadySet = true; - _checkWithVisitor(); - return true; - } - else + _alreadySet = true; + _checkWithVisitor(); + return true; + } + else return false; - } - - /** - * Checks to see if the value parsed is in the allowed list. - */ - template - void ValueArg::_checkAllowed( const std::string& val ) - { - if ( _allowed.size() > 0 ) - if ( find(_allowed.begin(),_allowed.end(),_value) == _allowed.end() ) - throw( ArgException( "Couldn't find '" + val + - "' in allowed list.", toString() ) ); - } - - /** - * Implementation of shortID. - */ - template - std::string ValueArg::shortID(const std::string& val) const - { - return Arg::shortID( _typeDesc ); - } - - /** - * Implementation of longID. - */ - template - std::string ValueArg::longID(const std::string& val) const - { - return Arg::longID( _typeDesc ); - } - } + +/** + * Checks to see if the value parsed is in the allowed list. + */ +template +void ValueArg::_checkAllowed( const std::string& val ) +{ + if ( _allowed.size() > 0 ) + if ( find(_allowed.begin(),_allowed.end(),_value) == _allowed.end() ) + throw( ArgException( "Couldn't find '" + val + + "' in allowed list.", toString() ) ); +} + +/** + * Implementation of shortID. + */ +template +std::string ValueArg::shortID(const std::string& val) const +{ + return Arg::shortID( _typeDesc ); +} + +/** + * Implementation of longID. + */ +template +std::string ValueArg::longID(const std::string& val) const +{ + return Arg::longID( _typeDesc ); +} + +template +void ValueArg::_extractValue( const std::string& val ) +{ + VALUE_ARG_HELPER::ValueExtractor ve(_value); + + int err = ve.extractValue(val); + + if ( err == VALUE_ARG_HELPER::EFAIL ) + throw( ArgException("Couldn't read argument value from string '" + + val + "'", toString() ) ); + + if ( err == VALUE_ARG_HELPER::EMANY ) + throw( ArgException("More than one valid value parsed from string '" + + val + "'", toString() ) ); + + _checkAllowed( val ); +} + +} // namespace TCLAP + #endif