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 {
    friend class CmdLine;
    friend class CmdLineInterface;
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");
        if (parser.attachGroup(*this)) return;
        // Preserve the legacy path for custom CmdLineInterface implementations.
        _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->conflictsWith(**it)) {
            throw SpecificationException(
                "Argument with same flag/name already exists!", arg->longID());
        }
    }
 
    Container members(_args);
    members.push_back(arg);
    if (_parser) {
        _parser->addToArgList(arg);
    }
    _args.swap(members);
 
    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