#include <Arg.h>

Public Member Functions | |
| bool | _hasBlanks (const std::string &s) const | 
| virtual bool | acceptsMultipleValues () | 
| virtual void | addToList (std::list< Arg * > &argList) const | 
| virtual bool | allowMore () | 
| virtual bool | argMatches (const std::string &s) const | 
| void | forceRequired () | 
| std::string | getDescription () const | 
| const std::string & | getFlag () const | 
| const std::string & | getName () const | 
| bool | isIgnoreable () const | 
| virtual bool | isRequired () const | 
| bool | isSet () const | 
| bool | isValueRequired () const | 
| virtual std::string | longID (const std::string &valueId="val") const | 
| virtual bool | operator== (const Arg &a) const | 
| virtual bool | processArg (int *i, std::vector< std::string > &args)=0 | 
| virtual void | reset () | 
| void | setRequireLabel (const std::string &s) | 
| virtual std::string | shortID (const std::string &valueId="val") const | 
| virtual std::string | toString () const | 
| virtual void | trimFlag (std::string &flag, std::string &value) const | 
| void | xorSet () | 
| virtual | ~Arg () | 
Static Public Member Functions | |
| static void | beginIgnoring () | 
| static char | blankChar () | 
| static char | delimiter () | 
| static char | flagStartChar () | 
| static const std::string | flagStartString () | 
| static const std::string | ignoreNameString () | 
| static bool | ignoreRest () | 
| static const std::string | nameStartString () | 
| static void | setDelimiter (char c) | 
Protected Member Functions | |
| void | _checkWithVisitor () const | 
| Arg (const std::string &flag, const std::string &name, const std::string &desc, bool req, bool valreq, Visitor *v=NULL) | |
Protected Attributes | |
| bool | _acceptsMultipleValues | 
| bool | _alreadySet | 
| std::string | _description | 
| std::string | _flag | 
| bool | _ignoreable | 
| std::string | _name | 
| bool | _required | 
| std::string | _requireLabel | 
| bool | _valueRequired | 
| Visitor * | _visitor | 
| bool | _xorSet | 
Private Member Functions | |
| Arg (const Arg &rhs) | |
| Arg & | operator= (const Arg &rhs) | 
Static Private Member Functions | |
| static char & | delimiterRef () | 
| static bool & | ignoreRestRef () | 
A virtual base class that defines the essential data for all arguments. This class, or one of its existing children, must be subclassed to do anything.
| TCLAP::Arg::Arg | ( | const Arg & | rhs | ) |  [private] | 
        
Prevent accidental copying.
| TCLAP::Arg::Arg | ( | const std::string & | flag, | 
| const std::string & | name, | ||
| const std::string & | desc, | ||
| bool | req, | ||
| bool | valreq, | ||
| Visitor * | v = NULL  | 
        ||
| ) |  [inline, protected] | 
        
Primary constructor. YOU (yes you) should NEVER construct an Arg directly, this is a base class that is extended by various children that are meant to be used. Use SwitchArg, ValueArg, MultiArg, UnlabeledValueArg, or UnlabeledMultiArg instead.
| flag | - The flag identifying the argument. | 
| name | - The name identifying the argument. | 
| desc | - The description of the argument, used in the usage. | 
| req | - Whether the argument is required. | 
| valreq | - Whether the a value is required for the argument. | 
| v | - The visitor checked by the argument. Defaults to NULL. | 
| TCLAP::Arg::~Arg | ( | ) |  [inline, virtual] | 
        
| void TCLAP::Arg::_checkWithVisitor | ( | ) |  const [inline, protected] | 
        
| bool TCLAP::Arg::_hasBlanks | ( | const std::string & | s | ) |  const [inline] | 
        
| bool TCLAP::Arg::acceptsMultipleValues | ( | ) |  [inline, virtual] | 
        
| void TCLAP::Arg::addToList | ( | std::list< Arg * > & | argList | ) |  const [inline, virtual] | 
        
Adds this to the specified list of Args.
| argList | - The list to add this to. | 
Overridden by Args that need to added to the end of the list.
Reimplemented in TCLAP::UnlabeledValueArg< T >, and TCLAP::UnlabeledMultiArg< T >.
| bool TCLAP::Arg::allowMore | ( | ) |  [inline, virtual] | 
        
Used for MultiArgs and XorHandler to determine whether args can still be set.
Reimplemented in TCLAP::MultiArg< T >.
| bool TCLAP::Arg::argMatches | ( | const std::string & | s | ) |  const [inline, virtual] | 
        
A method that tests whether a string matches this argument. This is generally called by the processArg() method. This method could be re-implemented by a child to change how arguments are specified on the command line.
| s | - The string to be compared to the flag/name to determine whether the arg matches. | 
| static void TCLAP::Arg::beginIgnoring | ( | ) |  [inline, static] | 
        
| static char TCLAP::Arg::blankChar | ( | ) |  [inline, static] | 
        
| static char TCLAP::Arg::delimiter | ( | ) |  [inline, static] | 
        
| static char& TCLAP::Arg::delimiterRef | ( | ) |  [inline, static, private] | 
        
| static char TCLAP::Arg::flagStartChar | ( | ) |  [inline, static] | 
        
| static const std::string TCLAP::Arg::flagStartString | ( | ) |  [inline, static] | 
        
| void TCLAP::Arg::forceRequired | ( | ) |  [inline] | 
        
Sets _required to true. This is used by the XorHandler. You really have no reason to ever use it.
| std::string TCLAP::Arg::getDescription | ( | ) |  const [inline] | 
        
| const std::string & TCLAP::Arg::getFlag | ( | ) |  const [inline] | 
        
| const std::string & TCLAP::Arg::getName | ( | void | ) |  const [inline] | 
        
| static const std::string TCLAP::Arg::ignoreNameString | ( | ) |  [inline, static] | 
        
| static bool TCLAP::Arg::ignoreRest | ( | ) |  [inline, static] | 
        
| static bool& TCLAP::Arg::ignoreRestRef | ( | ) |  [inline, static, private] | 
        
| bool TCLAP::Arg::isIgnoreable | ( | ) |  const [inline] | 
        
| bool TCLAP::Arg::isRequired | ( | ) |  const [inline, virtual] | 
        
Indicates whether the argument is required.
Reimplemented in TCLAP::MultiArg< T >.
| bool TCLAP::Arg::isSet | ( | ) |  const [inline] | 
        
| bool TCLAP::Arg::isValueRequired | ( | ) |  const [inline] | 
        
| std::string TCLAP::Arg::longID | ( | const std::string & | valueId = "val" | ) |  const [inline, virtual] | 
        
Returns a long ID for the usage.
| valueId | - The value used in the id. | 
Reimplemented in TCLAP::ValueArg< T >, TCLAP::MultiArg< T >, TCLAP::UnlabeledValueArg< T >, TCLAP::UnlabeledMultiArg< T >, and TCLAP::MultiSwitchArg.
| static const std::string TCLAP::Arg::nameStartString | ( | ) |  [inline, static] | 
        
| bool TCLAP::Arg::operator== | ( | const Arg & | a | ) |  const [inline, virtual] | 
        
Operator ==. Equality operator. Must be virtual to handle unlabeled args.
| a | - The Arg to be compared to this. | 
Reimplemented in TCLAP::UnlabeledValueArg< T >, and TCLAP::UnlabeledMultiArg< T >.
| virtual bool TCLAP::Arg::processArg | ( | int * | i, | 
| std::vector< std::string > & | args | ||
| ) |  [pure virtual] | 
        
Pure virtual method meant to handle the parsing and value assignment of the string on the command line.
| i | - Pointer the the current argument in the list. | 
| args | - Mutable list of strings. What is passed in from main. | 
Implemented in TCLAP::ValueArg< T >, TCLAP::UnlabeledValueArg< T >, TCLAP::MultiArg< T >, TCLAP::UnlabeledMultiArg< T >, TCLAP::MultiSwitchArg, and TCLAP::SwitchArg.
| void TCLAP::Arg::reset | ( | ) |  [inline, virtual] | 
        
Clears the Arg object and allows it to be reused by new command lines.
Reimplemented in TCLAP::ValueArg< T >, TCLAP::MultiArg< T >, TCLAP::MultiSwitchArg, and TCLAP::SwitchArg.
| static void TCLAP::Arg::setDelimiter | ( | char | c | ) |  [inline, static] | 
        
| void TCLAP::Arg::setRequireLabel | ( | const std::string & | s | ) |  [inline] | 
        
Sets the requireLabel. Used by XorHandler. You shouldn't ever use this.
| s | - Set the requireLabel to this value. | 
| std::string TCLAP::Arg::shortID | ( | const std::string & | valueId = "val" | ) |  const [inline, virtual] | 
        
Returns a short ID for the usage.
| valueId | - The value used in the id. | 
Reimplemented in TCLAP::ValueArg< T >, TCLAP::MultiArg< T >, TCLAP::UnlabeledValueArg< T >, TCLAP::UnlabeledMultiArg< T >, and TCLAP::MultiSwitchArg.
| std::string TCLAP::Arg::toString | ( | ) |  const [inline, virtual] | 
        
| void TCLAP::Arg::trimFlag | ( | std::string & | flag, | 
| std::string & | value | ||
| ) |  const [inline, virtual] | 
        
| void TCLAP::Arg::xorSet | ( | ) |  [inline] | 
        
Sets the _alreadySet value to true. This is used by the XorHandler. You really have no reason to ever use it.
bool TCLAP::Arg::_acceptsMultipleValues [protected] | 
        
bool TCLAP::Arg::_alreadySet [protected] | 
        
std::string TCLAP::Arg::_description [protected] | 
        
std::string TCLAP::Arg::_flag [protected] | 
        
The single char flag used to identify the argument. This value (preceded by a dash {-}), can be used to identify an argument on the command line. The _flag can be blank, in fact this is how unlabeled args work. Unlabeled args must override appropriate functions to get correct handling. Note that the _flag does NOT include the dash as part of the flag.
bool TCLAP::Arg::_ignoreable [protected] | 
        
std::string TCLAP::Arg::_name [protected] | 
        
bool TCLAP::Arg::_required [protected] | 
        
std::string TCLAP::Arg::_requireLabel [protected] | 
        
bool TCLAP::Arg::_valueRequired [protected] | 
        
Visitor* TCLAP::Arg::_visitor [protected] | 
        
bool TCLAP::Arg::_xorSet [protected] |