Arg.h

Go to the documentation of this file.

// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
/******************************************************************************
 *
 *  file:  Arg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno .
 *  Copyright (c) 2017 Google Inc.
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/
 
#ifndef TCLAP_ARG_H
#define TCLAP_ARG_H
 
#ifdef HAVE_TCLAP_CONFIG_H
#include <tclap/TCLAPConfig.h>
#endif
 
// Define to 1 before including TCLAP to retain the historical truncation of
// ValueLike input at its first NUL byte. Use one setting across the program.
#ifndef TCLAP_ALLOW_NUL_TRUNCATION
#define TCLAP_ALLOW_NUL_TRUNCATION 0
#endif
 
#include <tclap/ArgException.h>
#include <tclap/ArgTraits.h>
#include <tclap/CmdLineInterface.h>
#include <tclap/StandardTraits.h>
#include <tclap/Visitor.h>
#include <tclap/sstream.h>
 
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <string>
#include <vector>
 
namespace TCLAP {
 
struct ArgAlias {
    std::string flag;
    std::string name;
    ArgAlias(const std::string &f, const std::string &n) : flag(f), name(n) {}
};
 
class Arg {
    friend class CmdLine;
 
private:
    // NULL uses the legacy static delimiter for unregistered arguments.
    const char *_parserDelimiter;
    std::vector<ArgAlias> _aliases;
    // Registration validates against the destination parser's conventions.
    void _validateAliases(char delimiter, const std::string &flagPrefix,
                          const std::string &namePrefix) const;
    bool _aliasConflictsWithDialect(const ArgAlias &alias, char delimiter,
                                    const std::string &flagPrefix,
                                    const std::string &namePrefix) const;
    void _validateAliasToken(const std::string &label, const std::string &prefix,
                             std::vector<std::string> &tokens) const;
    void _validateAliasLabels(const std::string &flag,
                               const std::string &name) const;
    bool _matchesDeclaredToken(const std::string &token,
                               const std::string &flagPrefix,
                               const std::string &namePrefix) const;
    bool _aliasConflictsWith(const Arg &other, const std::string &flagPrefix,
                             const std::string &namePrefix) const;
 
    Arg(const Arg &rhs);
 
    Arg &operator=(const Arg &rhs);
 
    static char &delimiterRef() {
        static char delim = ' ';
        return delim;
    }
 
protected:
    bool matchesShortFlag(const std::string &flag) const;
    bool matchesLongName(const std::string &name) const;
    std::string _flag;
 
    std::string _name;
 
    std::string _description;
 
    const bool _required;
 
    std::string _requireLabel;
 
    bool _valueRequired;
 
    bool _alreadySet;
 
    std::string _setBy;
 
    Visitor *_visitor;
 
    bool _ignoreable;
 
    bool _acceptsMultipleValues;
 
    bool _visibleInHelp;
 
    void _checkWithVisitor() const;
 
    Arg(const std::string &flag, const std::string &name,
        const std::string &desc, bool req, bool valreq, Visitor *v = NULL);
 
public:
    Arg &addAlias(const std::string &flag, const std::string &name = "");
 
    const std::vector<ArgAlias> &aliases() const { return _aliases; }
 
    virtual ~Arg();
 
    virtual void addToList(std::list<Arg *> &argList) const;
 
    static char delimiter() { return delimiterRef(); }
 
    char getDelimiter() const {
        return _parserDelimiter ? *_parserDelimiter : delimiter();
    }
 
    static char blankChar() { return '\a'; }
 
#ifndef TCLAP_FLAGSTARTCHAR
#define TCLAP_FLAGSTARTCHAR '-'
#endif
    static char flagStartChar() { return TCLAP_FLAGSTARTCHAR; }
 
#ifndef TCLAP_FLAGSTARTSTRING
#define TCLAP_FLAGSTARTSTRING "-"
#endif
    static const std::string flagStartString() { return TCLAP_FLAGSTARTSTRING; }
 
#ifndef TCLAP_NAMESTARTSTRING
#define TCLAP_NAMESTARTSTRING "--"
#endif
    static const std::string nameStartString() { return TCLAP_NAMESTARTSTRING; }
 
    static const 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;
 
    bool conflictsWith(const Arg &a) const;
 
    const std::string &getFlag() const;
 
    const std::string &getName() const;
 
    std::string getDescription() const { return getDescription(_required); }
 
    virtual void setDescription(const std::string &desc) { _description = desc; }
 
    std::string getDescription(bool required) const {
        return (required ? "(" + _requireLabel + ") " : "") + _description;
    }
 
    virtual bool isRequired() const;
 
    bool isValueRequired() const;
 
    bool isSet() const;
 
    const std::string &setBy() const { return _setBy; }
 
    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;
 
    virtual bool allowMore();
 
    virtual bool acceptsMultipleValues();
 
    virtual void reset();
 
    virtual void hideFromHelp(bool hide = true) { _visibleInHelp = !hide; }
 
    virtual bool visibleInHelp() const { return _visibleInHelp; }
 
    virtual bool hasLabel() const { return true; }
};
 
typedef std::list<Arg *>::const_iterator ArgListIterator;
 
typedef std::vector<Arg *>::const_iterator ArgVectorIterator;
 
typedef std::list<Visitor *>::const_iterator VisitorListIterator;
 
/*
 * Extract a value of type T from it's string representation contained
 * in strVal. The ValueLike parameter used to select the correct
 * specialization of ExtractValue depending on the value traits of T.
 * ValueLike traits use operator>> to assign the value from strVal.
 */
template <typename T>
void ExtractValue(T &destVal, const std::string &strVal, ValueLike vl) {
    static_cast<void>(vl);  // Avoid warning about unused vl
#if !TCLAP_ALLOW_NUL_TRUNCATION
    if (strVal.find('\0') != std::string::npos)
        throw ArgParseException("Embedded NUL in argument value");
#endif
    istringstream is(strVal.c_str());
 
    int valuesRead = 0;
    // Let the extractor decide whether an explicitly empty input is valid.
    // Built-in numeric extraction fails; a custom extractor may accept it.
    if (strVal.empty()) {
        is >> destVal;
        ++valuesRead;
    }
    while (is.good()) {
        if (is.peek() != EOF)
#ifdef TCLAP_SETBASE_ZERO
            is >> std::setbase(0) >> destVal;
#else
            is >> destVal;
#endif
        else
            break;
 
        valuesRead++;
    }
 
    if (is.fail())
        throw(
            ArgParseException("Couldn't read argument value "
                              "from string '" +
                              strVal + "'"));
 
    if (valuesRead > 1)
        throw(
            ArgParseException("More than one valid value parsed from "
                              "string '" +
                              strVal + "'"));
}
 
/*
 * Extract a value of type T from it's string representation contained
 * in strVal. The ValueLike parameter used to select the correct
 * specialization of ExtractValue depending on the value traits of T.
 * StringLike uses assignment (operator=) to assign from strVal.
 */
template <typename T>
void ExtractValue(T &destVal, const std::string &strVal, StringLike sl) {
    static_cast<void>(sl);  // Avoid warning about unused sl
    SetString(destVal, strVal);
}
 
// BEGIN Arg.cpp
 
inline Arg::Arg(const std::string &flag, const std::string &name,
                const std::string &desc, bool req, bool valreq, Visitor *v)
    : _parserDelimiter(NULL),
      _aliases(),
      _flag(flag),
      _name(name),
      _description(desc),
      _required(req),
      _requireLabel("required"),
      _valueRequired(valreq),
      _alreadySet(false),
      _setBy(),
      _visitor(v),
      _ignoreable(true),
      _acceptsMultipleValues(false),
      _visibleInHelp(true) {
    if (_flag.length() > 1)
        throw(SpecificationException(
            "Argument flag can only be one character long", Arg::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.",
            Arg::toString()));
 
    if ((_name.substr(0, Arg::flagStartString().length()) ==
         Arg::flagStartString()) ||
        (_name.substr(0, Arg::nameStartString().length()) ==
         Arg::nameStartString()) ||
        (_name.find(" ", 0) != std::string::npos))
        throw(SpecificationException("Argument name begin with either '" +
                                         Arg::flagStartString() + "' or '" +
                                         Arg::nameStartString() + "' or space.",
                                     Arg::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;
 
    if (_valueRequired) id += std::string(1, getDelimiter()) + valueId;
 
    return id;
}
 
inline std::string Arg::longID(const std::string &valueId) const {
    std::string id = "";
 
    if (_flag != "") {
        id += Arg::flagStartString() + _flag;
 
        if (_valueRequired) id += std::string(1, getDelimiter()) + valueId;
 
        id += ",  ";
    }
 
    id += Arg::nameStartString() + _name;
 
    if (_valueRequired) id += std::string(1, getDelimiter()) + valueId;
 
    for (std::vector<ArgAlias>::const_iterator it = _aliases.begin();
         it != _aliases.end(); ++it) {
        if (!it->flag.empty()) {
            id += ",  " + flagStartString() + it->flag;
            if (_valueRequired) id += std::string(1, getDelimiter()) + valueId;
        }
        if (!it->name.empty()) {
            id += ",  " + nameStartString() + it->name;
            if (_valueRequired) id += std::string(1, getDelimiter()) + valueId;
        }
    }
    return id;
}
 
inline bool Arg::_matchesDeclaredToken(const std::string &token,
                                       const std::string &flagPrefix,
                                       const std::string &namePrefix) const {
    if ((!_flag.empty() && token == flagPrefix + _flag) ||
        token == namePrefix + _name)
        return true;
    for (std::vector<ArgAlias>::const_iterator it = _aliases.begin();
         it != _aliases.end(); ++it)
        if ((!it->flag.empty() && token == flagPrefix + it->flag) ||
            (!it->name.empty() && token == namePrefix + it->name))
            return true;
    return false;
}
 
inline bool Arg::_aliasConflictsWith(const Arg &other,
                                     const std::string &flagPrefix,
                                     const std::string &namePrefix) const {
    for (std::vector<ArgAlias>::const_iterator it = _aliases.begin();
         it != _aliases.end(); ++it)
        if ((!it->flag.empty() &&
             other._matchesDeclaredToken(flagPrefix + it->flag, flagPrefix,
                                         namePrefix)) ||
            (!it->name.empty() &&
             other._matchesDeclaredToken(namePrefix + it->name, flagPrefix,
                                         namePrefix)))
            return true;
    return false;
}
 
inline void Arg::_validateAliases(char delimiter, const std::string &flagPrefix,
                                  const std::string &namePrefix) const {
    if (_aliases.empty()) return;
    std::vector<std::string> tokens;
    if (!_flag.empty()) tokens.push_back(flagPrefix + _flag);
    tokens.push_back(namePrefix + _name);
    for (std::vector<ArgAlias>::const_iterator it = _aliases.begin();
         it != _aliases.end(); ++it) {
        if (_aliasConflictsWithDialect(*it, delimiter, flagPrefix, namePrefix))
            throw SpecificationException("Alias conflicts with parser dialect",
                                         toString());
        _validateAliasToken(it->flag, flagPrefix, tokens);
        _validateAliasToken(it->name, namePrefix, tokens);
    }
}
 
inline bool Arg::_aliasConflictsWithDialect(
    const ArgAlias &alias, char delimiter, const std::string &flagPrefix,
    const std::string &namePrefix) const {
    return (!alias.flag.empty() &&
            (alias.flag == flagPrefix || alias.flag == namePrefix)) ||
           (!alias.name.empty() &&
            ((!flagPrefix.empty() && alias.name.find(flagPrefix) == 0) ||
             (!namePrefix.empty() && alias.name.find(namePrefix) == 0))) ||
           (_valueRequired &&
            (alias.flag.find(delimiter) != std::string::npos ||
             alias.name.find(delimiter) != std::string::npos));
}
 
inline void Arg::_validateAliasToken(const std::string &label,
                                     const std::string &prefix,
                                     std::vector<std::string> &tokens) const {
    if (label.empty()) return;
    const std::string token = prefix + label;
    for (std::vector<std::string>::const_iterator it = tokens.begin();
         it != tokens.end(); ++it)
        if (*it == token)
            throw SpecificationException("Duplicate argument alias token",
                                         toString());
    tokens.push_back(token);
}
 
inline bool Arg::matchesShortFlag(const std::string &flag) const {
    if (flag.empty()) return false;
    if (flag == _flag) return true;
    for (std::vector<ArgAlias>::const_iterator it = _aliases.begin();
         it != _aliases.end(); ++it)
        if (flag == it->flag) return true;
    return false;
}
 
inline bool Arg::matchesLongName(const std::string &name) const {
    if (name.empty()) return false;
    if (name == _name) return true;
    for (std::vector<ArgAlias>::const_iterator it = _aliases.begin();
         it != _aliases.end(); ++it)
        if (name == it->name) return true;
    return false;
}
 
inline Arg &Arg::addAlias(const std::string &flag, const std::string &name) {
    if (_parserDelimiter)
        throw SpecificationException("Aliases must be added before registration", toString());
    if (!hasLabel())
        throw SpecificationException("Positional arguments cannot have aliases", toString());
    _validateAliasLabels(flag, name);
    if (matchesShortFlag(flag) || matchesLongName(name))
        throw SpecificationException("Duplicate argument alias", toString());
    _aliases.push_back(ArgAlias(flag, name));
    return *this;
}
 
inline void Arg::_validateAliasLabels(const std::string &flag,
                                      const std::string &name) const {
    if ((flag.empty() && name.empty()) || flag.size() > 1 ||
        flag == flagStartString() || flag == nameStartString() ||
        flag.find_first_of(" \t\r\n\v\f\a") != std::string::npos ||
        flag.find('\0') != std::string::npos ||
        name.find_first_of(" \t\r\n\v\f") != std::string::npos ||
        name.find('\0') != std::string::npos ||
        (!name.empty() && (name.find(flagStartString()) == 0 ||
                          name.find(nameStartString()) == 0)))
        throw SpecificationException("Invalid argument alias", toString());
    const std::string labels = flag + name;
    for (std::string::const_iterator it = labels.begin(); it != labels.end();
         ++it)
        if (static_cast<unsigned char>(*it) < 0x20 || *it == '\x7f')
            throw SpecificationException("Control byte in argument alias",
                                         toString());
}
 
inline bool Arg::conflictsWith(const Arg &a) const {
    if (this == &a || _name == a._name || matchesLongName(a._name) || matchesShortFlag(a._flag))
        return true;
    for (std::vector<ArgAlias>::const_iterator it = a._aliases.begin();
         it != a._aliases.end(); ++it)
        if (matchesShortFlag(it->flag) || matchesLongName(it->name)) return true;
    return false;
}
 
inline bool Arg::operator==(const Arg &a) const {
    return (_flag != "" && _flag == a._flag) || _name == a._name;
}
 
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 { return _alreadySet; }
 
inline bool Arg::isIgnoreable() const { return _ignoreable; }
 
inline bool Arg::argMatches(const std::string &argFlag) const {
    const std::string shortPrefix = flagStartString();
    const std::string longPrefix = nameStartString();
    return argFlag == longPrefix + _name ||
           (argFlag.find(shortPrefix) == 0 &&
            matchesShortFlag(argFlag.substr(shortPrefix.size()))) ||
           (argFlag.find(longPrefix) == 0 &&
            matchesLongName(argFlag.substr(longPrefix.size())));
}
 
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] == getDelimiter()) {
            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::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; }
 
inline void Arg::reset() { _alreadySet = false; }
 
// END Arg.cpp
 
}  // namespace TCLAP
 
#endif  // TCLAP_ARG_H