cuberite/TCLAP
1
0
Fork 0
mirror of https://github.com/cuberite/TCLAP.git synced 2025-09-13 06:07:07 -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

8
include/tclap/Arg.h
View File

@ -50,15 +50,14 @@ class Arg
*/
static bool& ignoreRestRef() { static bool ign = false; return ign; }
protected:
/**
* The delimiter that separates an argument flag/name from the
* value.
*/
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<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;
}

16
include/tclap/CmdLine.h
View File

@ -37,8 +37,6 @@
#include <list>
#include <iostream>
#include <ostream>
#include <cstdio>
#include <cstdarg>
#include <iomanip>
#include <algorithm>
@ -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 );
}
@ -436,7 +439,8 @@ inline void CmdLine::parse(int argc, char** argv)
_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);
}

14
include/tclap/CmdLineInterface.h
View File

@ -36,15 +36,19 @@
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
{
class CmdLineInterface
{
public:
/**
* Destructor
*/
virtual ~CmdLineInterface() {}
/**
@ -93,7 +97,7 @@ namespace TCLAP {
* \param argv - Array of arguments.
*/
virtual void parse(int argc, char** argv)=0;
};
};
} //namespace

283
include/tclap/MultiArg.h
View File

@ -1,5 +1,3 @@
/* -*- Mode: CC; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/******************************************************************************
*
* file: MultiArg.h
@ -33,38 +31,53 @@
namespace TCLAP {
template<class T> class MultiArg;
template<class T> 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 T>
class ValueExtractor
{
/**
* 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 T>
class ValueExtractor
{
friend class MultiArg<T>;
private:
/**
* Reference to the vector of values where the result of the
* extraction will be put.
*/
std::vector<T> &_values;
/**
* Constructor.
* \param values - Where the values extracted will be put.
*/
ValueExtractor(std::vector<T> &values) : _values(values) {}
int extractValue( const std::string& val ) {
/**
* 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() ) {
while ( is.good() )
{
if ( is.peek() != EOF )
is >> temp;
else
@ -83,37 +96,54 @@ namespace MULTI_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<std::string> {
template<>
class ValueExtractor<std::string>
{
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;
/**
* Constructor.
* \param values - Where the strings extracted will be put.
*/
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 );
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 T>
class MultiArg : public Arg
{
template<class T>
class MultiArg : public Arg
{
protected:
/**
@ -140,21 +170,7 @@ namespace MULTI_ARG_HELPER {
* is thrown.
* \param val - The string to be read.
*/
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 );
}
void _extractValue( const std::string& val );
/**
* Checks to see if parsed value is in allowed list.
@ -213,6 +229,7 @@ namespace MULTI_ARG_HELPER {
const std::string& typeDesc,
CmdLineInterface& parser,
Visitor* v = NULL );
/**
* Constructor.
* \param flag - The one character flag that identifies this
@ -299,14 +316,14 @@ namespace MULTI_ARG_HELPER {
* Common initialization code for constructors with allowed vectors.
*/
void allowedInit();
};
};
/**
/**
*
*/
template<class T>
void MultiArg<T>::allowedInit()
{
template<class T>
void MultiArg<T>::allowedInit()
{
for ( unsigned int i = 0; i < _allowed.size(); i++ )
{
std::ostringstream os;
@ -316,81 +333,82 @@ namespace MULTI_ARG_HELPER {
if ( i > 0 )
_typeDesc += "|";
_typeDesc += temp;
}
}
}
/**
/**
*
*/
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
template<class T>
MultiArg<T>::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 ),
: Arg( flag, name, desc, req, true, v ),
_typeDesc( typeDesc )
{ }
{ }
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
template<class T>
MultiArg<T>::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 ),
: Arg( flag, name, desc, req, true, v ),
_typeDesc( typeDesc )
{
{
parser.add( this );
}
}
/**
/**
*
*/
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
const std::vector<T>& allowed,
Visitor* v)
: Arg( flag, name, desc, req, true, v ),
: Arg( flag, name, desc, req, true, v ),
_allowed( allowed )
{
{
allowedInit();
}
}
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
const std::vector<T>& allowed,
CmdLineInterface& parser,
Visitor* v)
: Arg( flag, name, desc, req, true, v ),
: Arg( flag, name, desc, req, true, v ),
_allowed( allowed )
{
{
allowedInit();
parser.add( this );
}
}
/**
/**
*
*/
template<class T>
const std::vector<T>& MultiArg<T>::getValue() { return _values; }
template<class T>
const std::vector<T>& MultiArg<T>::getValue() { return _values; }
/**
/**
*
*/
template<class T>
bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args)
{
template<class T>
bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args)
{
if ( _ignoreable && Arg::ignoreRest() )
return false;
@ -421,100 +439,55 @@ namespace MULTI_ARG_HELPER {
_extractValue( value );
_checkWithVisitor();
return true;
}
else
return false;
}
}
/*
template<class T>
void MultiArg<T>::_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<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 )
{
template<class T>
void MultiArg<T>::_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() ) );
}
}
/**
/**
*
*/
template<class T>
std::string MultiArg<T>::shortID(const std::string& val) const
{
template<class T>
std::string MultiArg<T>::shortID(const std::string& val) const
{
std::string id = Arg::shortID(_typeDesc) + " ... ";
return id;
}
}
/**
/**
*
*/
template<class T>
std::string MultiArg<T>::longID(const std::string& val) const
{
template<class T>
std::string MultiArg<T>::longID(const std::string& val) const
{
std::string id = Arg::longID(_typeDesc) + " (accepted multiple times)";
return id;
}
}
/**
/**
* Once we've matched the first value, then the arg is no longer
* required.
*/
template<class T>
bool MultiArg<T>::isRequired() const
{
template<class T>
bool MultiArg<T>::isRequired() const
{
if ( _required )
{
if ( _values.size() > 1 )
@ -525,8 +498,26 @@ namespace MULTI_ARG_HELPER {
else
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

2
include/tclap/PrintSensibly.h
View File

@ -39,7 +39,7 @@ 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,
inline void spacePrint( std::ostream& os,
const std::string& s,
int maxWidth,
int indentSpaces=0,

231
include/tclap/ValueArg.h
View File

@ -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 T> class ValueArg;
template<class T> class ValueArg;
namespace VALUE_ARG_HELPER {
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 T> class ValueExtractor {
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 T> class ValueExtractor
{
/**
*
*/
friend class ValueArg<T>;
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,30 +95,49 @@ 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<std::string> {
template<> class ValueExtractor<std::string>
{
/**
*
*/
friend class ValueArg<std::string>;
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
@ -109,9 +145,9 @@ namespace VALUE_ARG_HELPER {
* an unflagged ValueArg, it is unwise and would cause significant problems.
* Instead use an UnlabeledValueArg.
*/
template<class T>
class ValueArg : public Arg
{
template<class T>
class ValueArg : public Arg
{
protected:
/**
@ -144,19 +180,7 @@ namespace VALUE_ARG_HELPER {
* is thrown.
* \param val - value to be parsed.
*/
void _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 );
}
void _extractValue( const std::string& val );
/**
* Checks to see if parsed value is in allowed list.
@ -326,12 +350,12 @@ namespace VALUE_ARG_HELPER {
*/
void allowedInit();
};
};
template<class T>
void ValueArg<T>::allowedInit()
{
template<class T>
void ValueArg<T>::allowedInit()
{
for ( unsigned int i = 0; i < _allowed.size(); i++ )
{
std::ostringstream os;
@ -343,26 +367,26 @@ namespace VALUE_ARG_HELPER {
_typeDesc += "|";
_typeDesc += temp;
}
}
}
/**
/**
* Constructor implementation.
*/
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
template<class T>
ValueArg<T>::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),
: Arg(flag, name, desc, req, true, v),
_value( val ),
_typeDesc( typeDesc )
{ }
{ }
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
@ -370,33 +394,33 @@ namespace VALUE_ARG_HELPER {
const std::string& typeDesc,
CmdLineInterface& parser,
Visitor* v)
: Arg(flag, name, desc, req, true, v),
: Arg(flag, name, desc, req, true, v),
_value( val ),
_typeDesc( typeDesc )
{
{
parser.add( this );
}
}
/**
/**
* Constructor with allowed list.
*/
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T val,
const std::vector<T>& allowed,
Visitor* v)
: Arg(flag, name, desc, req, true, v),
: Arg(flag, name, desc, req, true, v),
_value( val ),
_allowed( allowed )
{
{
allowedInit();
}
}
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
@ -404,27 +428,27 @@ namespace VALUE_ARG_HELPER {
const std::vector<T>& allowed,
CmdLineInterface& parser,
Visitor* v)
: Arg(flag, name, desc, req, true, v),
_value( val ),
_allowed( allowed )
{
: Arg(flag, name, desc, req, true, v),
_value( val ),
_allowed( allowed )
{
allowedInit();
parser.add( this );
}
}
/**
/**
* Implementation of getValue().
*/
template<class T>
T& ValueArg<T>::getValue() { return _value; }
template<class T>
T& ValueArg<T>::getValue() { return _value; }
/**
/**
* Implementation of processArg().
*/
template<class T>
bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args)
{
template<class T>
bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args)
{
if ( _ignoreable && Arg::ignoreRest() )
return false;
@ -463,37 +487,56 @@ namespace VALUE_ARG_HELPER {
}
else
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 )
{
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
{
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
{
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