cuberite/TCLAP
1
0
Fork 0
mirror of https://github.com/cuberite/TCLAP.git synced 2025-09-12 13:46:02 -04:00
Code Issues Packages Projects Releases Wiki Activity

minor formatting

Browse Source
This commit is contained in:
mes5k 2004-09-26 23:54:16 +00:00
parent 5b198cd996
commit ad7f3fdab3
6 changed files with 909 additions and 867 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/tclap/Arg.h
View File

@ -48,10 +48,7 @@ class Arg
/** /**
* Indicates whether the rest of the arguments should be ignored. * Indicates whether the rest of the arguments should be ignored.
*/ */
static bool& ignoreRestRef() { static bool ign = false; return ign; } static bool& ignoreRestRef() { static bool ign = false; return ign; }
protected:
/** /**
* The delimiter that separates an argument flag/name from the * The delimiter that separates an argument flag/name from the
@ -59,6 +56,8 @@ class Arg
*/ */
static char& delimiterRef() { static char delim = ' '; return delim; } static char& delimiterRef() { static char delim = ' '; return delim; }
protected:
/** /**
* The single char flag used to identify the argument. * The single char flag used to identify the argument.
* This value (preceded by a dash {-}), can be used to identify * 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 // should be overridden
inline bool Arg::processArg(int* i, std::vector<std::string>& args) inline bool Arg::processArg(int* i, std::vector<std::string>& args)
{ {
std::cerr << "WARNING: Ignoring unknown argument: " << args[*i] << std::endl; std::cerr << "WARNING: Ignoring unknown argument: "
<< args[*i] << std::endl;
return false; return false;
} }

18
include/tclap/CmdLine.h
View File

@ -37,8 +37,6 @@
#include <list> #include <list>
#include <iostream> #include <iostream>
#include <ostream> #include <ostream>
#include <cstdio>
#include <cstdarg>
#include <iomanip> #include <iomanip>
#include <algorithm> #include <algorithm>
@ -231,7 +229,9 @@ class CmdLine : public CmdLineInterface
//Begin CmdLine.cpp //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), : _progName(n),
_message(m), _message(m),
_version(v), _version(v),
@ -241,7 +241,9 @@ inline CmdLine::CmdLine(const std::string& n, const std::string& m, const std::s
_constructor(); _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"), : _progName("not_set_yet"),
_message(m), _message(m),
_version(v), _version(v),
@ -339,7 +341,8 @@ inline void CmdLine::add( Arg* a )
inline void CmdLine::version(int exitVal) 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 ); exit( exitVal );
} }
@ -429,14 +432,15 @@ inline void CmdLine::parse(int argc, char** argv)
} catch ( ArgException e ) } catch ( ArgException e )
{ {
std::cerr << "PARSE ERROR: " << e.argId() << std::endl 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; std::cerr << "Brief USAGE: " << std::endl;
_shortUsage( std::cerr ); _shortUsage( std::cerr );
std::cerr << std::endl << "For complete USAGE and HELP type: " 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); exit(1);
} }

104
include/tclap/CmdLineInterface.h
View File

@ -36,64 +36,68 @@
namespace TCLAP { namespace TCLAP {
class Arg; class Arg;
/** /**
* The base class that manages the command line definition and passes * The base class that manages the command line definition and passes
* along the parsing to the appropriate Arg classes. * along the parsing to the appropriate Arg classes.
*/ */
class CmdLineInterface class CmdLineInterface
{ {
public: public:
virtual ~CmdLineInterface() {}
/** /**
* Adds an argument to the list of arguments to be parsed. * Destructor
* \param a - Argument to be added. */
*/ virtual ~CmdLineInterface() {}
virtual void add( Arg& a )=0;
/** /**
* An alternative add. Functionally identical. * Adds an argument to the list of arguments to be parsed.
* \param a - Argument to be added. * \param a - Argument to be added.
*/ */
virtual void add( Arg* a )=0; virtual void add( Arg& a )=0;
/** /**
* Add two Args that will be xor'd. * An alternative add. Functionally identical.
* If this method is used, add does * \param a - Argument to be added.
* not need to be called. */
* \param a - Argument to be added and xor'd. virtual void add( Arg* a )=0;
* \param b - Argument to be added and xor'd.
*/
virtual void xorAdd( Arg& a, Arg& b )=0;
/** /**
* Add a list of Args that will be xor'd. If this method is used, * Add two Args that will be xor'd.
* add does not need to be called. * If this method is used, add does
* \param xors - List of Args to be added and xor'd. * not need to be called.
*/ * \param a - Argument to be added and xor'd.
virtual void xorAdd( std::vector<Arg*>& xors )=0; * \param b - Argument to be added and xor'd.
*/
virtual void xorAdd( Arg& a, Arg& b )=0;
/** /**
* Prints the usage to stdout and exits. * Add a list of Args that will be xor'd. If this method is used,
* \param exitVal - Value to exit with. * add does not need to be called.
*/ * \param xors - List of Args to be added and xor'd.
virtual void usage( int exitVal = 0 )=0; */
virtual void xorAdd( std::vector<Arg*>& xors )=0;
/** /**
* Prints the version to stdout and exits. * Prints the usage to stdout and exits.
* \param exitVal - Value to exit with. * \param exitVal - Value to exit with.
*/ */
virtual void version( int exitVal = 0 )=0; virtual void usage( int exitVal = 0 )=0;
/** /**
* Parses the command line. * Prints the version to stdout and exits.
* \param argc - Number of arguments. * \param exitVal - Value to exit with.
* \param argv - Array of arguments. */
*/ virtual void version( int exitVal = 0 )=0;
virtual void parse(int argc, char** argv)=0;
}; /**
* Parses the command line.
* \param argc - Number of arguments.
* \param argv - Array of arguments.
*/
virtual void parse(int argc, char** argv)=0;
};
} //namespace } //namespace

829
include/tclap/MultiArg.h
View File

@ -1,5 +1,3 @@
/* -*- Mode: CC; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/****************************************************************************** /******************************************************************************
* *
* file: MultiArg.h * file: MultiArg.h
@ -33,500 +31,493 @@
namespace TCLAP { namespace TCLAP {
template<class T> class MultiArg; template<class T> class MultiArg;
namespace MULTI_ARG_HELPER { namespace MULTI_ARG_HELPER {
enum Error_e { enum Error_e { EFAIL = 1000, EMANY };
EFAIL = 1000,
EMANY
};
//This class is used to extract a value from an argument. /**
//It is used because we need a special implementation to * This class is used to extract a value from an argument.
//deal with std::string and making a specialiced function * It is used because we need a special implementation to
//puts it in the T segment, thus generating link errors. * deal with std::string and making a specialiced function
//Having a specialiced class makes the symbols weak. * puts it in the T segment, thus generating link errors.
//This is not pretty but I don't know how to make it * Having a specialiced class makes the symbols weak.
//work any other way. * This is not pretty but I don't know how to make it
template<class T> * work any other way.
class ValueExtractor */
{ template<class T>
friend class MultiArg<T>; class ValueExtractor
{
friend class MultiArg<T>;
private: private:
std::vector<T> &_values;
/**
* Reference to the vector of values where the result of the
* extraction will be put.
*/
std::vector<T> &_values;
ValueExtractor(std::vector<T> &values) : _values(values) {} /**
* Constructor.
* \param values - Where the values extracted will be put.
*/
ValueExtractor(std::vector<T> &values) : _values(values) {}
int extractValue( const std::string& val ) { /**
T temp; * Method that will attempt to parse the input stream for values
std::istringstream is(val); * of type T.
int valuesRead = 0; * \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() ) { while ( is.good() )
if ( is.peek() != EOF ) {
is >> temp; if ( is.peek() != EOF )
else is >> temp;
break; else
break;
valuesRead++; valuesRead++;
} }
if ( is.fail() ) if ( is.fail() )
return EFAIL; return EFAIL;
if ( valuesRead > 1 ) if ( valuesRead > 1 )
return EMANY; return EMANY;
_values.push_back(temp); _values.push_back(temp);
return 0; return 0;
} }
}; };
/** /**
* Specialization for string. This is necessary because istringstream * Specialization for string. This is necessary because istringstream
* operator>> is not able to ignore spaces... meaning -x "X Y" will only * operator>> is not able to ignore spaces... meaning -x "X Y" will only
* read 'X'... and thus the specialization. * read 'X'... and thus the specialization.
*/ */
template<> template<>
class ValueExtractor<std::string> { class ValueExtractor<std::string>
friend class MultiArg<std::string>; {
private: friend class MultiArg<std::string>;
private:
/**
* Reference to the vector of strings where the result of the
* extraction will be put.
*/
std::vector<std::string> &_values; std::vector<std::string> &_values;
/**
* Constructor.
* \param values - Where the strings extracted will be put.
*/
ValueExtractor(std::vector<std::string> &values) : _values(values) {} ValueExtractor(std::vector<std::string> &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 ); _values.push_back( val );
return 0; return 0;
} }
}; };
} //namespace MULTI_ARG_HELPER } //namespace MULTI_ARG_HELPER
/** /**
* An argument that allows multiple values of type T to be specified. Very * 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 * similar to a ValueArg, except a vector of values will be returned
* instead of just one. * instead of just one.
*/ */
template<class T> template<class T>
class MultiArg : public Arg class MultiArg : public Arg
{ {
protected: protected:
/** /**
* The list of values parsed from the CmdLine. * The list of values parsed from the CmdLine.
*/ */
std::vector<T> _values; std::vector<T> _values;
/** /**
* A list of allowed values. * A list of allowed values.
* A list of values allowed for this argument. If the value parsed * 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 * for this arg is not found in this list, then an exception is
* thrown. If the list is empty, then any value is allowed. * thrown. If the list is empty, then any value is allowed.
*/ */
std::vector<T> _allowed; std::vector<T> _allowed;
/** /**
* The description of type T to be used in the usage. * The description of type T to be used in the usage.
*/ */
std::string _typeDesc; std::string _typeDesc;
/** /**
* Extracts the value from the string. * Extracts the value from the string.
* Attempts to parse string as type T, if this fails an exception * Attempts to parse string as type T, if this fails an exception
* is thrown. * is thrown.
* \param val - The string to be read. * \param val - The string to be read.
*/ */
void _extractValue( const std::string& val ) { void _extractValue( const std::string& val );
MULTI_ARG_HELPER::ValueExtractor<T> 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 );
}
/** /**
* Checks to see if parsed value is in allowed list. * Checks to see if parsed value is in allowed list.
* \param val - value parsed (only used in output). * \param val - value parsed (only used in output).
*/ */
void _checkAllowed( const std::string& val ); void _checkAllowed( const std::string& val );
public: public:
/** /**
* Constructor. * Constructor.
* \param flag - The one character flag that identifies this * \param flag - The one character flag that identifies this
* argument on the command line. * argument on the command line.
* \param name - A one word name for the argument. Can be * \param name - A one word name for the argument. Can be
* used as a long flag on the command line. * used as a long flag on the command line.
* \param desc - A description of what the argument is for or * \param desc - A description of what the argument is for or
* does. * does.
* \param req - Whether the argument is required on the command * \param req - Whether the argument is required on the command
* line. * line.
* \param typeDesc - A short, human readable description of the * \param typeDesc - A short, human readable description of the
* type that this object expects. This is used in the generation * 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 USAGE statement. The goal is to be helpful to the end user
* of the program. * of the program.
* \param v - An optional visitor. You probably should not * \param v - An optional visitor. You probably should not
* use this unless you have a very good reason. * use this unless you have a very good reason.
*/ */
MultiArg( const std::string& flag, MultiArg( const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
const std::string& typeDesc, const std::string& typeDesc,
Visitor* v = NULL); Visitor* v = NULL);
/** /**
* Constructor. * Constructor.
* \param flag - The one character flag that identifies this * \param flag - The one character flag that identifies this
* argument on the command line. * argument on the command line.
* \param name - A one word name for the argument. Can be * \param name - A one word name for the argument. Can be
* used as a long flag on the command line. * used as a long flag on the command line.
* \param desc - A description of what the argument is for or * \param desc - A description of what the argument is for or
* does. * does.
* \param req - Whether the argument is required on the command * \param req - Whether the argument is required on the command
* line. * line.
* \param typeDesc - A short, human readable description of the * \param typeDesc - A short, human readable description of the
* type that this object expects. This is used in the generation * 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 USAGE statement. The goal is to be helpful to the end user
* of the program. * of the program.
* \param parser - A CmdLine parser object to add this Arg to * \param parser - A CmdLine parser object to add this Arg to
* \param v - An optional visitor. You probably should not * \param v - An optional visitor. You probably should not
* use this unless you have a very good reason. * use this unless you have a very good reason.
*/ */
MultiArg( const std::string& flag, MultiArg( const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
const std::string& typeDesc, const std::string& typeDesc,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v = NULL ); Visitor* v = NULL );
/**
* Constructor. /**
* \param flag - The one character flag that identifies this * Constructor.
* argument on the command line. * \param flag - The one character flag that identifies this
* \param name - A one word name for the argument. Can be * argument on the command line.
* used as a long flag on the command line. * \param name - A one word name for the argument. Can be
* \param desc - A description of what the argument is for or * used as a long flag on the command line.
* does. * \param desc - A description of what the argument is for or
* \param req - Whether the argument is required on the command * does.
* line. * \param req - Whether the argument is required on the command
* \param allowed - A vector of type T that where the values in the * line.
* vector are the only values allowed for the arg. * \param allowed - A vector of type T that where the values in the
* \param v - An optional visitor. You probably should not * vector are the only values allowed for the arg.
* use this unless you have a very good reason. * \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, MultiArg( const std::string& flag,
const std::string& desc, const std::string& name,
bool req, const std::string& desc,
const std::vector<T>& allowed, bool req,
Visitor* v = NULL ); const std::vector<T>& allowed,
Visitor* v = NULL );
/** /**
* Constructor. * Constructor.
* \param flag - The one character flag that identifies this * \param flag - The one character flag that identifies this
* argument on the command line. * argument on the command line.
* \param name - A one word name for the argument. Can be * \param name - A one word name for the argument. Can be
* used as a long flag on the command line. * used as a long flag on the command line.
* \param desc - A description of what the argument is for or * \param desc - A description of what the argument is for or
* does. * does.
* \param req - Whether the argument is required on the command * \param req - Whether the argument is required on the command
* line. * line.
* \param allowed - A vector of type T that where the values in the * \param allowed - A vector of type T that where the values in the
* vector are the only values allowed for the arg. * vector are the only values allowed for the arg.
* \param parser - A CmdLine parser object to add this Arg to * \param parser - A CmdLine parser object to add this Arg to
* \param v - An optional visitor. You probably should not * \param v - An optional visitor. You probably should not
* use this unless you have a very good reason. * use this unless you have a very good reason.
*/ */
MultiArg( const std::string& flag, MultiArg( const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
const std::vector<T>& allowed, const std::vector<T>& allowed,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v = NULL ); Visitor* v = NULL );
/** /**
* Handles the processing of the argument. * Handles the processing of the argument.
* This re-implements the Arg version of this method to set the * This re-implements the Arg version of this method to set the
* _value of the argument appropriately. It knows the difference * _value of the argument appropriately. It knows the difference
* between labeled and unlabeled. * between labeled and unlabeled.
* \param i - Pointer the the current argument in the list. * \param i - Pointer the the current argument in the list.
* \param args - Mutable list of strings. Passed from main(). * \param args - Mutable list of strings. Passed from main().
*/ */
virtual bool processArg(int* i, std::vector<std::string>& args); virtual bool processArg(int* i, std::vector<std::string>& args);
/** /**
* Returns a vector of type T containing the values parsed from * Returns a vector of type T containing the values parsed from
* the command line. * the command line.
*/ */
const std::vector<T>& getValue(); const std::vector<T>& getValue();
/** /**
* Returns the a short id string. Used in the usage. * Returns the a short id string. Used in the usage.
* \param val - value to be used. * \param val - value to be used.
*/ */
virtual std::string shortID(const std::string& val="val") const; virtual std::string shortID(const std::string& val="val") const;
/** /**
* Returns the a long id string. Used in the usage. * Returns the a long id string. Used in the usage.
* \param val - value to be used. * \param val - value to be used.
*/ */
virtual std::string longID(const std::string& val="val") const; virtual std::string longID(const std::string& val="val") const;
/** /**
* Once we've matched the first value, then the arg is no longer * Once we've matched the first value, then the arg is no longer
* required. * required.
*/ */
virtual bool isRequired() const; virtual bool isRequired() const;
private: private:
/** /**
* Common initialization code for constructors with allowed vectors. * Common initialization code for constructors with allowed vectors.
*/ */
void allowedInit(); void allowedInit();
}; };
/** /**
* *
*/ */
template<class T> template<class T>
void MultiArg<T>::allowedInit() void MultiArg<T>::allowedInit()
{ {
for ( unsigned int i = 0; i < _allowed.size(); i++ ) for ( unsigned int i = 0; i < _allowed.size(); i++ )
{ {
std::ostringstream os; std::ostringstream os;
os << _allowed[i]; os << _allowed[i];
std::string temp( os.str() ); std::string temp( os.str() );
if ( i > 0 ) if ( i > 0 )
_typeDesc += "|"; _typeDesc += "|";
_typeDesc += temp;
} _typeDesc += temp;
} }
}
/** /**
* *
*/ */
template<class T> template<class T>
MultiArg<T>::MultiArg(const std::string& flag, MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
const std::string& typeDesc, const std::string& typeDesc,
Visitor* v) Visitor* v)
: Arg( flag, name, desc, req, true, v ), : Arg( flag, name, desc, req, true, v ),
_typeDesc( typeDesc ) _typeDesc( typeDesc )
{ } { }
template<class T> template<class T>
MultiArg<T>::MultiArg(const std::string& flag, MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
const std::string& typeDesc, const std::string& typeDesc,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v) Visitor* v)
: Arg( flag, name, desc, req, true, v ), : Arg( flag, name, desc, req, true, v ),
_typeDesc( typeDesc ) _typeDesc( typeDesc )
{ {
parser.add( this ); parser.add( this );
} }
/** /**
* *
*/ */
template<class T> template<class T>
MultiArg<T>::MultiArg(const std::string& flag, MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
const std::vector<T>& allowed, const std::vector<T>& allowed,
Visitor* v) Visitor* v)
: Arg( flag, name, desc, req, true, v ), : Arg( flag, name, desc, req, true, v ),
_allowed( allowed ) _allowed( allowed )
{ {
allowedInit(); allowedInit();
} }
template<class T> template<class T>
MultiArg<T>::MultiArg(const std::string& flag, MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
const std::vector<T>& allowed, const std::vector<T>& allowed,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v) Visitor* v)
: Arg( flag, name, desc, req, true, v ), : Arg( flag, name, desc, req, true, v ),
_allowed( allowed ) _allowed( allowed )
{ {
allowedInit(); allowedInit();
parser.add( this ); parser.add( this );
} }
/** /**
* *
*/ */
template<class T> template<class T>
const std::vector<T>& MultiArg<T>::getValue() { return _values; } const std::vector<T>& MultiArg<T>::getValue() { return _values; }
/** /**
* *
*/ */
template<class T> template<class T>
bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args) bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args)
{ {
if ( _ignoreable && Arg::ignoreRest() ) if ( _ignoreable && Arg::ignoreRest() )
return false; return false;
if ( _hasBlanks( args[*i] ) ) if ( _hasBlanks( args[*i] ) )
return false; return false;
std::string flag = args[*i]; std::string flag = args[*i];
std::string value = ""; std::string value = "";
trimFlag( flag, value ); trimFlag( flag, value );
if ( argMatches( flag ) ) if ( argMatches( flag ) )
{ {
if ( Arg::delimiter() != ' ' && value == "" ) if ( Arg::delimiter() != ' ' && value == "" )
throw( ArgException( "Couldn't find delimiter for this argument!", throw( ArgException( "Couldn't find delimiter for this argument!",
toString() ) ); toString() ) );
if ( value == "" ) if ( value == "" )
{ {
(*i)++; (*i)++;
if ( (unsigned int)*i < args.size() ) if ( (unsigned int)*i < args.size() )
_extractValue( args[*i] ); _extractValue( args[*i] );
else else
throw( ArgException("Missing a value for this argument!", throw( ArgException("Missing a value for this argument!",
toString() ) ); toString() ) );
} }
else else
_extractValue( value ); _extractValue( value );
_checkWithVisitor(); _checkWithVisitor();
return true;
} return true;
else }
else
return false; return false;
} }
/* /**
template<class T> * Checks to see if the value parsed is in the allowed list.
void MultiArg<T>::_extractValue( const std::string& val ) */
{ template<class T>
T temp; void MultiArg<T>::_checkAllowed( const std::string& val )
std::istringstream is(val); {
if ( _allowed.size() > 0 )
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<std::string>::_extractValue( const std::string& val )
{
_values.push_back( val );
_checkAllowed( val );
}
*/
/**
* Checks to see if the value parsed is in the allowed list.
*/
template<class T>
void MultiArg<T>::_checkAllowed( const std::string& val )
{
if ( _allowed.size() > 0 )
if ( find(_allowed.begin(),_allowed.end(),_values.back()) if ( find(_allowed.begin(),_allowed.end(),_values.back())
== _allowed.end() ) == _allowed.end() )
throw( ArgException( "Couldn't find '" + val + throw( ArgException( "Couldn't find '" + val +
"' in allowed list.", toString() ) ); "' in allowed list.", toString() ) );
} }
/** /**
* *
*/ */
template<class T> template<class T>
std::string MultiArg<T>::shortID(const std::string& val) const std::string MultiArg<T>::shortID(const std::string& val) const
{ {
std::string id = Arg::shortID(_typeDesc) + " ... "; std::string id = Arg::shortID(_typeDesc) + " ... ";
return id; return id;
} }
/** /**
* *
*/ */
template<class T> template<class T>
std::string MultiArg<T>::longID(const std::string& val) const std::string MultiArg<T>::longID(const std::string& val) const
{ {
std::string id = Arg::longID(_typeDesc) + " (accepted multiple times)"; 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 * Once we've matched the first value, then the arg is no longer
* required. * required.
*/ */
template<class T> template<class T>
bool MultiArg<T>::isRequired() const bool MultiArg<T>::isRequired() const
{ {
if ( _required ) if ( _required )
{ {
if ( _values.size() > 1 ) if ( _values.size() > 1 )
return false; return false;
else else
return true; return true;
} }
else else
return false; return false;
}
} }
template<class T>
void MultiArg<T>::_extractValue( const std::string& val )
{
MULTI_ARG_HELPER::ValueExtractor<T> 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 #endif

10
include/tclap/PrintSensibly.h
View File

@ -39,11 +39,11 @@ namespace TCLAP {
* \param secondLineOffset - The number of spaces to indent the second * \param secondLineOffset - The number of spaces to indent the second
* and all subsequent lines in addition to indentSpaces. * and all subsequent lines in addition to indentSpaces.
*/ */
inline void spacePrint( std::ostream& os, inline void spacePrint( std::ostream& os,
const std::string& s, const std::string& s,
int maxWidth, int maxWidth,
int indentSpaces=0, int indentSpaces=0,
int secondLineOffset=0 ) int secondLineOffset=0 )
{ {
int len = (int)(s.length()); int len = (int)(s.length());

805
include/tclap/ValueArg.h
View File

@ -1,5 +1,3 @@
/* -*- Mode: CC; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/****************************************************************************** /******************************************************************************
* *
* file: ValueArg.h * file: ValueArg.h
@ -33,35 +31,54 @@
namespace TCLAP { namespace TCLAP {
template<class T> class ValueArg; template<class T> class ValueArg;
namespace VALUE_ARG_HELPER { namespace VALUE_ARG_HELPER {
enum Error_e { enum Error_e { EFAIL = 1000, EMANY };
EFAIL = 1000,
EMANY
};
//This class is used to extract a value from an argument. /**
//It is used because we need a special implementation to * This class is used to extract a value from an argument.
//deal with std::string and making a specialiced function * It is used because we need a special implementation to
//puts it in the T segment, thus generating link errors. * deal with std::string and making a specialiced function
//Having a specialiced class makes the symbols weak. * puts it in the T segment, thus generating link errors.
//This is not pretty but I don't know how to make it * Having a specialiced class makes the symbols weak.
//work any other way. * This is not pretty but I don't know how to make it
template<class T> class ValueExtractor { * work any other way.
*/
friend class ValueArg<T>; template<class T> class ValueExtractor
private: {
/**
*
*/
friend class ValueArg<T>;
private:
/**
* Reference to the value where the result of the extraction will
* be put.
*/
T &_value; 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); std::istringstream is(val);
int valuesRead = 0; int valuesRead = 0;
while ( is.good() ) { while ( is.good() )
{
if ( is.peek() != EOF ) if ( is.peek() != EOF )
is >> _value; is >> _value;
else else
@ -78,422 +95,448 @@ namespace VALUE_ARG_HELPER {
return 0; return 0;
} }
}; };
/** /**
* Specialization for string. This is necessary because istringstream * Specialization for string. This is necessary because istringstream
* operator>> is not able to ignore spaces... meaning -x "X Y" will only * operator>> is not able to ignore spaces... meaning -x "X Y" will only
* read 'X'... and thus the specialization. * read 'X'... and thus the specialization.
*/ */
template<> class ValueExtractor<std::string> { template<> class ValueExtractor<std::string>
{
friend class ValueArg<std::string>; /**
private: *
*/
friend class ValueArg<std::string>;
private:
/**
* Reference to the value where the result of the extraction will
* be put.
*/
std::string &_value; std::string &_value;
/**
* Constructor.
* \param value - Where the value extracted will be put.
*/
ValueExtractor(std::string &value) : _value(value) {} 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; _value = val;
return 0; return 0;
} }
}; };
} //namespace VALUE_ARG_HELPER } //namespace VALUE_ARG_HELPER
/** /**
* The basic labeled argument that parses a value. * The basic labeled argument that parses a value.
* This is a template class, which means the type T defines the type * 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 * 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 * on the command line. While there is nothing stopping you from creating
* an unflagged ValueArg, it is unwise and would cause significant problems. * an unflagged ValueArg, it is unwise and would cause significant problems.
* Instead use an UnlabeledValueArg. * Instead use an UnlabeledValueArg.
*/ */
template<class T> template<class T>
class ValueArg : public Arg class ValueArg : public Arg
{ {
protected: protected:
/** /**
* The value parsed from the command line. * The value parsed from the command line.
* Can be of any type, as long as the >> operator for the type * Can be of any type, as long as the >> operator for the type
* is defined. * is defined.
*/ */
T _value; T _value;
/** /**
* A list of allowed values. * A list of allowed values.
* A list of values allowed for this argument. If the value parsed * 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 * for this arg is not found in this list, then an exception is
* thrown. If the list is empty, then any value is allowed. * thrown. If the list is empty, then any value is allowed.
*/ */
std::vector<T> _allowed; std::vector<T> _allowed;
/** /**
* A human readable description of the type to be parsed. * A human readable description of the type to be parsed.
* This is a hack, plain and simple. Ideally we would use RTTI to * 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 * return the name of type T, but until there is some sort of
* consistent support for human readable names, we are left to our * consistent support for human readable names, we are left to our
* own devices. * own devices.
*/ */
std::string _typeDesc; std::string _typeDesc;
/** /**
* Extracts the value from the string. * Extracts the value from the string.
* Attempts to parse string as type T, if this fails an exception * Attempts to parse string as type T, if this fails an exception
* is thrown. * is thrown.
* \param val - value to be parsed. * \param val - value to be parsed.
*/ */
void _extractValue( const std::string& val ) { void _extractValue( const std::string& val );
VALUE_ARG_HELPER::ValueExtractor<T> ve(_value);
int err = ve.extractValue(val); /**
if(err == VALUE_ARG_HELPER::EFAIL) * Checks to see if parsed value is in allowed list.
throw( ArgException("Couldn't read argument value from string '" + * \param val - value parsed (only used in output).
val + "'", toString() ) ); */
if(err == VALUE_ARG_HELPER::EMANY) void _checkAllowed( const std::string& val );
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 );
public: public:
/** /**
* Labeled ValueArg constructor. * Labeled ValueArg constructor.
* You could conceivably call this constructor with a blank flag, * You could conceivably call this constructor with a blank flag,
* but that would make you a bad person. It would also cause * but that would make you a bad person. It would also cause
* an exception to be thrown. If you want an unlabeled argument, * an exception to be thrown. If you want an unlabeled argument,
* use the other constructor. * use the other constructor.
* \param flag - The one character flag that identifies this * \param flag - The one character flag that identifies this
* argument on the command line. * argument on the command line.
* \param name - A one word name for the argument. Can be * \param name - A one word name for the argument. Can be
* used as a long flag on the command line. * used as a long flag on the command line.
* \param desc - A description of what the argument is for or * \param desc - A description of what the argument is for or
* does. * does.
* \param req - Whether the argument is required on the command * \param req - Whether the argument is required on the command
* line. * line.
* \param value - The default value assigned to this argument if it * \param value - The default value assigned to this argument if it
* is not present on the command line. * is not present on the command line.
* \param typeDesc - A short, human readable description of the * \param typeDesc - A short, human readable description of the
* type that this object expects. This is used in the generation * 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 USAGE statement. The goal is to be helpful to the end user
* of the program. * of the program.
* \param v - An optional visitor. You probably should not * \param v - An optional visitor. You probably should not
* use this unless you have a very good reason. * use this unless you have a very good reason.
*/ */
ValueArg( const std::string& flag, ValueArg( const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T value, T value,
const std::string& typeDesc, const std::string& typeDesc,
Visitor* v = NULL); Visitor* v = NULL);
/** /**
* Labeled ValueArg constructor. * Labeled ValueArg constructor.
* You could conceivably call this constructor with a blank flag, * You could conceivably call this constructor with a blank flag,
* but that would make you a bad person. It would also cause * but that would make you a bad person. It would also cause
* an exception to be thrown. If you want an unlabeled argument, * an exception to be thrown. If you want an unlabeled argument,
* use the other constructor. * use the other constructor.
* \param flag - The one character flag that identifies this * \param flag - The one character flag that identifies this
* argument on the command line. * argument on the command line.
* \param name - A one word name for the argument. Can be * \param name - A one word name for the argument. Can be
* used as a long flag on the command line. * used as a long flag on the command line.
* \param desc - A description of what the argument is for or * \param desc - A description of what the argument is for or
* does. * does.
* \param req - Whether the argument is required on the command * \param req - Whether the argument is required on the command
* line. * line.
* \param value - The default value assigned to this argument if it * \param value - The default value assigned to this argument if it
* is not present on the command line. * is not present on the command line.
* \param typeDesc - A short, human readable description of the * \param typeDesc - A short, human readable description of the
* type that this object expects. This is used in the generation * 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 USAGE statement. The goal is to be helpful to the end user
* of the program. * of the program.
* \param parser - A CmdLine parser object to add this Arg to * \param parser - A CmdLine parser object to add this Arg to
* \param v - An optional visitor. You probably should not * \param v - An optional visitor. You probably should not
* use this unless you have a very good reason. * use this unless you have a very good reason.
*/ */
ValueArg( const std::string& flag, ValueArg( const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T value, T value,
const std::string& typeDesc, const std::string& typeDesc,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v = NULL ); Visitor* v = NULL );
/** /**
* Labeled ValueArg constructor. * Labeled ValueArg constructor.
* You could conceivably call this constructor with a blank flag, * You could conceivably call this constructor with a blank flag,
* but that would make you a bad person. It would also cause * but that would make you a bad person. It would also cause
* an exception to be thrown. If you want an unlabeled argument, * an exception to be thrown. If you want an unlabeled argument,
* use the other constructor. * use the other constructor.
* \param flag - The one character flag that identifies this * \param flag - The one character flag that identifies this
* argument on the command line. * argument on the command line.
* \param name - A one word name for the argument. Can be * \param name - A one word name for the argument. Can be
* used as a long flag on the command line. * used as a long flag on the command line.
* \param desc - A description of what the argument is for or * \param desc - A description of what the argument is for or
* does. * does.
* \param req - Whether the argument is required on the command * \param req - Whether the argument is required on the command
* line. * line.
* \param value - The default value assigned to this argument if it * \param value - The default value assigned to this argument if it
* is not present on the command line. * is not present on the command line.
* \param allowed - A vector of type T that where the values in the * \param allowed - A vector of type T that where the values in the
* vector are the only values allowed for the arg. * vector are the only values allowed for the arg.
* \param parser - A CmdLine parser object to add this Arg to. * \param parser - A CmdLine parser object to add this Arg to.
* \param v - An optional visitor. You probably should not * \param v - An optional visitor. You probably should not
* use this unless you have a very good reason. * use this unless you have a very good reason.
*/ */
ValueArg( const std::string& flag, ValueArg( const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T value, T value,
const std::vector<T>& allowed, const std::vector<T>& allowed,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v = NULL ); Visitor* v = NULL );
/** /**
* Labeled ValueArg constructor. * Labeled ValueArg constructor.
* You could conceivably call this constructor with a blank flag, * You could conceivably call this constructor with a blank flag,
* but that would make you a bad person. It would also cause * but that would make you a bad person. It would also cause
* an exception to be thrown. If you want an unlabeled argument, * an exception to be thrown. If you want an unlabeled argument,
* use the other constructor. * use the other constructor.
* \param flag - The one character flag that identifies this * \param flag - The one character flag that identifies this
* argument on the command line. * argument on the command line.
* \param name - A one word name for the argument. Can be * \param name - A one word name for the argument. Can be
* used as a long flag on the command line. * used as a long flag on the command line.
* \param desc - A description of what the argument is for or * \param desc - A description of what the argument is for or
* does. * does.
* \param req - Whether the argument is required on the command * \param req - Whether the argument is required on the command
* line. * line.
* \param value - The default value assigned to this argument if it * \param value - The default value assigned to this argument if it
* is not present on the command line. * is not present on the command line.
* \param allowed - A vector of type T that where the values in the * \param allowed - A vector of type T that where the values in the
* vector are the only values allowed for the arg. * vector are the only values allowed for the arg.
* \param v - An optional visitor. You probably should not * \param v - An optional visitor. You probably should not
* use this unless you have a very good reason. * use this unless you have a very good reason.
*/ */
ValueArg( const std::string& flag, ValueArg( const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T value, T value,
const std::vector<T>& allowed, const std::vector<T>& allowed,
Visitor* v = NULL ); Visitor* v = NULL );
/** /**
* Handles the processing of the argument. * Handles the processing of the argument.
* This re-implements the Arg version of this method to set the * This re-implements the Arg version of this method to set the
* _value of the argument appropriately. It knows the difference * _value of the argument appropriately. It knows the difference
* between labeled and unlabeled. * between labeled and unlabeled.
* \param i - Pointer the the current argument in the list. * \param i - Pointer the the current argument in the list.
* \param args - Mutable list of strings. Passed * \param args - Mutable list of strings. Passed
* in from main(). * in from main().
*/ */
virtual bool processArg(int* i, std::vector<std::string>& args); virtual bool processArg(int* i, std::vector<std::string>& args);
/** /**
* Returns the value of the argument. * Returns the value of the argument.
*/ */
T& getValue() ; T& getValue() ;
/** /**
* Specialization of shortID. * Specialization of shortID.
* \param val - value to be used. * \param val - value to be used.
*/ */
virtual std::string shortID(const std::string& val = "val") const; virtual std::string shortID(const std::string& val = "val") const;
/** /**
* Specialization of longID. * Specialization of longID.
* \param val - value to be used. * \param val - value to be used.
*/ */
virtual std::string longID(const std::string& val = "val") const; virtual std::string longID(const std::string& val = "val") const;
private: private:
/** /**
* Common initialization code for constructors with allowed vectors. * Common initialization code for constructors with allowed vectors.
*/ */
void allowedInit(); void allowedInit();
}; };
template<class T> template<class T>
void ValueArg<T>::allowedInit() void ValueArg<T>::allowedInit()
{ {
for ( unsigned int i = 0; i < _allowed.size(); i++ ) for ( unsigned int i = 0; i < _allowed.size(); i++ )
{ {
std::ostringstream os; std::ostringstream os;
os << _allowed[i]; os << _allowed[i];
std::string temp( os.str() ); std::string temp( os.str() );
if ( i > 0 ) if ( i > 0 )
_typeDesc += "|"; _typeDesc += "|";
_typeDesc += temp; _typeDesc += temp;
} }
} }
/** /**
* Constructor implementation. * Constructor implementation.
*/ */
template<class T> template<class T>
ValueArg<T>::ValueArg(const std::string& flag, ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T val, T val,
const std::string& typeDesc, const std::string& typeDesc,
Visitor* v) Visitor* v)
: Arg(flag, name, desc, req, true, v), : Arg(flag, name, desc, req, true, v),
_value( val ), _value( val ),
_typeDesc( typeDesc ) _typeDesc( typeDesc )
{ } { }
template<class T> template<class T>
ValueArg<T>::ValueArg(const std::string& flag, ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T val, T val,
const std::string& typeDesc, const std::string& typeDesc,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v) Visitor* v)
: Arg(flag, name, desc, req, true, v), : Arg(flag, name, desc, req, true, v),
_value( val ), _value( val ),
_typeDesc( typeDesc ) _typeDesc( typeDesc )
{ {
parser.add( this ); parser.add( this );
} }
/** /**
* Constructor with allowed list. * Constructor with allowed list.
*/ */
template<class T> template<class T>
ValueArg<T>::ValueArg(const std::string& flag, ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T val, T val,
const std::vector<T>& allowed, const std::vector<T>& allowed,
Visitor* v) Visitor* v)
: Arg(flag, name, desc, req, true, v), : Arg(flag, name, desc, req, true, v),
_value( val ), _value( val ),
_allowed( allowed ) _allowed( allowed )
{ {
allowedInit(); allowedInit();
} }
template<class T> template<class T>
ValueArg<T>::ValueArg(const std::string& flag, ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name, const std::string& name,
const std::string& desc, const std::string& desc,
bool req, bool req,
T val, T val,
const std::vector<T>& allowed, const std::vector<T>& allowed,
CmdLineInterface& parser, CmdLineInterface& parser,
Visitor* v) Visitor* v)
: Arg(flag, name, desc, req, true, v), : Arg(flag, name, desc, req, true, v),
_value( val ), _value( val ),
_allowed( allowed ) _allowed( allowed )
{ {
allowedInit(); allowedInit();
parser.add( this ); parser.add( this );
} }
/** /**
* Implementation of getValue(). * Implementation of getValue().
*/ */
template<class T> template<class T>
T& ValueArg<T>::getValue() { return _value; } T& ValueArg<T>::getValue() { return _value; }
/** /**
* Implementation of processArg(). * Implementation of processArg().
*/ */
template<class T> template<class T>
bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args) bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args)
{ {
if ( _ignoreable && Arg::ignoreRest() ) if ( _ignoreable && Arg::ignoreRest() )
return false; return false;
if ( _hasBlanks( args[*i] ) ) if ( _hasBlanks( args[*i] ) )
return false; return false;
std::string flag = args[*i]; std::string flag = args[*i];
std::string value = ""; std::string value = "";
trimFlag( flag, value ); trimFlag( flag, value );
if ( argMatches( flag ) ) if ( argMatches( flag ) )
{ {
if ( _alreadySet ) if ( _alreadySet )
throw( ArgException("Argument already set!", toString()) ); throw( ArgException("Argument already set!", toString()) );
if ( Arg::delimiter() != ' ' && value == "" ) if ( Arg::delimiter() != ' ' && value == "" )
throw( ArgException( "Couldn't find delimiter for this argument!", throw( ArgException( "Couldn't find delimiter for this argument!",
toString() ) ); toString() ) );
if ( value == "" ) if ( value == "" )
{ {
(*i)++; (*i)++;
if ( (unsigned int)*i < args.size() ) if ( (unsigned int)*i < args.size() )
_extractValue( args[*i] ); _extractValue( args[*i] );
else else
throw( ArgException("Missing a value for this argument!", throw( ArgException("Missing a value for this argument!",
toString() ) ); toString() ) );
} }
else else
_extractValue( value ); _extractValue( value );
_alreadySet = true; _alreadySet = true;
_checkWithVisitor(); _checkWithVisitor();
return true; return true;
} }
else else
return false; return false;
}
/**
* Checks to see if the value parsed is in the allowed list.
*/
template<class T>
void ValueArg<T>::_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<class T>
std::string ValueArg<T>::shortID(const std::string& val) const
{
return Arg::shortID( _typeDesc );
}
/**
* Implementation of longID.
*/
template<class T>
std::string ValueArg<T>::longID(const std::string& val) const
{
return Arg::longID( _typeDesc );
}
} }
/**
* Checks to see if the value parsed is in the allowed list.
*/
template<class T>
void ValueArg<T>::_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<class T>
std::string ValueArg<T>::shortID(const std::string& val) const
{
return Arg::shortID( _typeDesc );
}
/**
* Implementation of longID.
*/
template<class T>
std::string ValueArg<T>::longID(const std::string& val) const
{
return Arg::longID( _typeDesc );
}
template<class T>
void ValueArg<T>::_extractValue( const std::string& val )
{
VALUE_ARG_HELPER::ValueExtractor<T> 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 #endif