ArgGroup.h

Go to the documentation of this file.

// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  ArgGroup.h
 *
 *  Copyright (c) 2017 Google LLC.
 *  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_GROUP_H
#define TCLAP_ARG_GROUP_H

#include <tclap/Arg.h>
#include <tclap/ArgContainer.h>
#include <tclap/CmdLineInterface.h>

#include <list>
#include <string>

namespace TCLAP {

class ArgGroup : public ArgContainer {
public:
    typedef std::list<Arg *> Container;
    typedef Container::iterator iterator;
    typedef Container::const_iterator const_iterator;

    virtual ~ArgGroup() {}

    virtual ArgContainer &add(Arg &arg) { return add(&arg); }

    virtual ArgContainer &add(Arg *arg);

    virtual bool validate() = 0;

    virtual bool isRequired() const = 0;

    virtual bool isExclusive() const = 0;

    void setParser(CmdLineInterface &parser) {
        if (_parser) {
            throw SpecificationException("Arg group can have only one parser");
        }

        _parser = &parser;
        for (iterator it = begin(); it != end(); ++it) {
            parser.addToArgList(*it);
        }
    }

    virtual bool showAsGroup() const { return true; }

    const std::string getName() const;

    iterator begin() { return _args.begin(); }
    iterator end() { return _args.end(); }
    const_iterator begin() const { return _args.begin(); }
    const_iterator end() const { return _args.end(); }

protected:
    // No direct instantiation
    ArgGroup() : _parser(0), _args() {}

private:
    explicit ArgGroup(const ArgGroup &);
    ArgGroup &operator=(const ArgGroup &);  // no copy

protected:
    CmdLineInterface *_parser;
    Container _args;
};

class ExclusiveArgGroup : public ArgGroup {
public:
    inline bool validate();
    bool isExclusive() const { return true; }
    ArgContainer &add(Arg &arg) { return add(&arg); }
    ArgContainer &add(Arg *arg) {
        if (arg->isRequired()) {
            throw SpecificationException(
                "Required arguments are not allowed"
                " in an exclusive grouping.",
                arg->longID());
        }

        return ArgGroup::add(arg);
    }

protected:
    ExclusiveArgGroup() {}
    explicit ExclusiveArgGroup(CmdLineInterface &parser) { parser.add(*this); }
};

class EitherOf : public ExclusiveArgGroup {
public:
    EitherOf() {}
    explicit EitherOf(CmdLineInterface &parser) : ExclusiveArgGroup(parser) {}

    bool isRequired() const { return false; }
};

class OneOf : public ExclusiveArgGroup {
public:
    OneOf() {}
    explicit OneOf(CmdLineInterface &parser) : ExclusiveArgGroup(parser) {}

    bool isRequired() const { return true; }
};

class AnyOf : public ArgGroup {
public:
    AnyOf() {}
    explicit AnyOf(CmdLineInterface &parser) { parser.add(*this); }

    bool validate() { return false; /* All good */ }
    bool isExclusive() const { return false; }
    bool isRequired() const { return false; }
};

inline ArgContainer &ArgGroup::add(Arg *arg) {
    for (iterator it = begin(); it != end(); it++) {
        if (*arg == **it) {
            throw SpecificationException(
                "Argument with same flag/name already exists!", arg->longID());
        }
    }

    _args.push_back(arg);
    if (_parser) {
        _parser->addToArgList(arg);
    }

    return *this;
}

inline bool ExclusiveArgGroup::validate() {
    Arg *arg = NULL;
    std::string flag;

    for (const_iterator it = begin(); it != end(); ++it) {
        if ((*it)->isSet()) {
            if (arg != NULL && !(*arg == **it)) {
                // We found a matching argument, but one was
                // already found previously.
                throw CmdLineParseException(
                    "Only one is allowed.",
                    flag + " AND " + (*it)->setBy() + " provided.");
            }

            arg = *it;
            flag = arg->setBy();
        }
    }

    return isRequired() && !arg;
}

inline const std::string ArgGroup::getName() const {
    std::string name;
    std::string sep = "{";  // TODO: this should change for
                            // non-exclusive arg groups
    for (const_iterator it = begin(); it != end(); ++it) {
        name += sep + (*it)->getName();
        sep = " | ";
    }

    return name + '}';
}

inline int CountVisibleArgs(const ArgGroup &g) {
    int visible = 0;
    for (ArgGroup::const_iterator it = g.begin(); it != g.end(); ++it) {
        if ((*it)->visibleInHelp()) {
            visible++;
        }
    }

    return visible;
}

}  // namespace TCLAP

#endif  // TCLAP_ARG_GROUP_H