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

#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 {

class Arg {
private:
    Arg(const Arg &rhs);

    Arg &operator=(const Arg &rhs);

    static char &delimiterRef() {
        static char delim = ' ';
        return delim;
    }

protected:
    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:
    virtual ~Arg();

    virtual void addToList(std::list<Arg *> &argList) const;

    static char delimiter() { return delimiterRef(); }

    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;

    const std::string &getFlag() const;

    const std::string &getName() const;

    std::string getDescription() const { return getDescription(_required); }

    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
    istringstream is(strVal.c_str());

    int valuesRead = 0;
    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)
    : _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", 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.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.",
                                     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, Arg::delimiter()) + 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, Arg::delimiter()) + valueId;

        id += ",  ";
    }

    id += Arg::nameStartString() + _name;

    if (_valueRequired) id += std::string(1, Arg::delimiter()) + 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 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 {
    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::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