Program Listing for File arg.hpp
↰ Return to documentation for file (include/ecl/command_line/arg.hpp
)
/*****************************************************************************
** Ifdefs
*****************************************************************************/
#ifndef TCLAP_ARGUMENT_H
#define TCLAP_ARGUMENT_H
#include <string>
#include <vector>
#include <list>
#include <iostream>
#include "arg_exception.hpp"
#include "visitor.hpp"
#include "cmd_line_interface.hpp"
namespace ecl {
class Arg
{
private:
static bool& ignoreRestRef() { static bool ign = false; return ign; }
static char& delimiterRef() { static char delim = ' '; return delim; }
protected:
std::string _flag;
std::string _name;
std::string _description;
bool _required;
std::string _requireLabel;
bool _valueRequired;
bool _alreadySet;
Visitor* _visitor;
bool _ignoreable;
bool _xorSet;
bool _acceptsMultipleValues;
void _checkWithVisitor() const;
Arg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
bool valreq,
Visitor* v = NULL );
public:
virtual ~Arg();
virtual void addToList( std::list<Arg*>& argList ) const;
static void beginIgnoring() { ignoreRestRef() = true; }
static bool ignoreRest() { return ignoreRestRef(); }
static char delimiter() { return delimiterRef(); }
static char blankChar() { return '*'; }
static char flagStartChar() { return '-'; }
static std::string flagStartString() { return "-"; }
static std::string nameStartString() { return "--"; }
static std::string ignoreNameString() { return "ignore_rest"; }
static void setDelimiter( char c ) { delimiterRef() = c; }
virtual bool processArg(int *i, std::vector<std::string>& args) = 0;
virtual bool operator==(const Arg& a) const;
const std::string& getFlag() const;
const std::string& getName() const;
std::string getDescription() const;
virtual bool isRequired() const;
void forceRequired();
void xorSet();
bool isValueRequired() const;
bool isSet() const;
bool isIgnoreable() const;
virtual bool argMatches( const std::string& s ) const;
virtual std::string toString() const;
virtual std::string shortID( const std::string& valueId = "val" ) const;
virtual std::string longID( const std::string& valueId = "val" ) const;
virtual void trimFlag( std::string& flag, std::string& value ) const;
bool _hasBlanks( const std::string& s ) const;
void setRequireLabel( const std::string& s );
virtual bool allowMore();
virtual bool acceptsMultipleValues();
};
typedef std::list<Arg*>::iterator ArgListIterator;
typedef std::vector<Arg*>::iterator ArgVectorIterator;
typedef std::list<Visitor*>::iterator VisitorListIterator;
//BEGIN Arg.cpp
inline Arg::Arg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
bool valreq,
Visitor* v) :
_flag(flag),
_name(name),
_description(desc),
_required(req),
_requireLabel("required"),
_valueRequired(valreq),
_alreadySet(false),
_visitor( v ),
_ignoreable(true),
_xorSet(false),
_acceptsMultipleValues(false)
{
if ( _flag.length() > 1 )
throw(SpecificationException(
"Argument flag can only be one character long", toString() ) );
if ( _name != ignoreNameString() &&
( _flag == Arg::flagStartString() ||
_flag == Arg::nameStartString() ||
_flag == " " ) )
throw(SpecificationException("Argument flag cannot be either '" +
Arg::flagStartString() + "' or '" +
Arg::nameStartString() + "' or a space.",
toString() ) );
if ( ( _name.find( Arg::flagStartString(), 0 ) != std::string::npos ) ||
( _name.find( Arg::nameStartString(), 0 ) != std::string::npos ) ||
( _name.find( " ", 0 ) != std::string::npos ) )
throw(SpecificationException("Argument name cannot contain either '" +
Arg::flagStartString() + "' or '" +
Arg::nameStartString() + "' or space.",
toString() ) );
}
inline Arg::~Arg() { }
inline std::string Arg::shortID( const std::string& valueId ) const
{
std::string id = "";
if ( _flag != "" )
id = Arg::flagStartString() + _flag;
else
id = Arg::nameStartString() + _name;
std::string delim = " ";
delim[0] = Arg::delimiter(); // ugly!!!
if ( _valueRequired )
id += delim + "<" + valueId + ">";
if ( !_required )
id = "[" + id + "]";
return id;
}
inline std::string Arg::longID( const std::string& valueId ) const
{
std::string id = "";
if ( _flag != "" )
{
id += Arg::flagStartString() + _flag;
if ( _valueRequired )
id += " <" + valueId + ">";
id += ", ";
}
id += Arg::nameStartString() + _name;
if ( _valueRequired )
id += " <" + valueId + ">";
return id;
}
inline bool Arg::operator==(const Arg& a) const
{
if ( ( _flag != "" && _flag == a._flag ) || _name == a._name)
return true;
else
return false;
}
inline std::string Arg::getDescription() const
{
std::string desc = "";
if ( _required )
desc = "(" + _requireLabel + ") ";
// if ( _valueRequired )
// desc += "(value required) ";
desc += _description;
return desc;
}
inline const std::string& Arg::getFlag() const { return _flag; }
inline const std::string& Arg::getName() const { return _name; }
inline bool Arg::isRequired() const { return _required; }
inline bool Arg::isValueRequired() const { return _valueRequired; }
inline bool Arg::isSet() const
{
if ( _alreadySet && !_xorSet )
return true;
else
return false;
}
inline bool Arg::isIgnoreable() const { return _ignoreable; }
inline void Arg::setRequireLabel( const std::string& s)
{
_requireLabel = s;
}
inline bool Arg::argMatches( const std::string& argFlag ) const
{
if ( ( argFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
argFlag == Arg::nameStartString() + _name )
return true;
else
return false;
}
inline std::string Arg::toString() const
{
std::string s = "";
if ( _flag != "" )
s += Arg::flagStartString() + _flag + " ";
s += "(" + Arg::nameStartString() + _name + ")";
return s;
}
inline void Arg::_checkWithVisitor() const
{
if ( _visitor != NULL )
_visitor->visit();
}
inline void Arg::trimFlag(std::string& flag, std::string& value) const
{
int stop = 0;
for ( int i = 0; static_cast<unsigned int>(i) < flag.length(); i++ )
if ( flag[i] == Arg::delimiter() )
{
stop = i;
break;
}
if ( stop > 1 )
{
value = flag.substr(stop+1);
flag = flag.substr(0,stop);
}
}
inline bool Arg::_hasBlanks( const std::string& s ) const
{
for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
if ( s[i] == Arg::blankChar() )
return true;
return false;
}
inline void Arg::forceRequired()
{
_required = true;
}
inline void Arg::xorSet()
{
_alreadySet = true;
_xorSet = true;
}
inline void Arg::addToList( std::list<Arg*>& argList ) const
{
argList.push_front( const_cast<Arg*>(this) );
}
inline bool Arg::allowMore()
{
return false;
}
inline bool Arg::acceptsMultipleValues()
{
return _acceptsMultipleValues;
}
//END Arg.cpp
} // namespace ecl
#endif