CmdLine.h

Go to the documentation of this file.

// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
/******************************************************************************
 *
 *  file:  CmdLine.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  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_CMDLINE_H
#define TCLAP_CMDLINE_H
 
#include <tclap/SwitchArg.h>
#include <tclap/MultiSwitchArg.h>
#include <tclap/UnlabeledValueArg.h>
#include <tclap/UnlabeledMultiArg.h>
 
#include <tclap/XorHandler.h>
#include <tclap/HelpVisitor.h>
#include <tclap/VersionVisitor.h>
#include <tclap/IgnoreRestVisitor.h>
 
#include <tclap/CmdLineOutput.h>
#include <tclap/StdOutput.h>
 
#include <tclap/Constraint.h>
#include <tclap/ValuesConstraint.h>
 
#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <stdlib.h> // Needed for exit(), which isn't defined in some envs.
 
namespace TCLAP {
 
template<typename T> void DelPtr(T ptr)
{
    delete ptr;
}
 
template<typename C> void ClearContainer(C &c)
{
    typedef typename C::value_type value_type;
    std::for_each(c.begin(), c.end(), DelPtr<value_type>);
    c.clear();
}
 
 
class CmdLine : public CmdLineInterface
{
    protected:
 
        std::list<Arg*> _argList;
 
        std::string _progName;
 
        std::string _message;
 
        std::string _version;
 
        int _numRequired;
 
        char _delimiter;
 
        XorHandler _xorHandler;
 
        std::list<Arg*> _argDeleteOnExitList;
 
        std::list<Visitor*> _visitorDeleteOnExitList;
 
        CmdLineOutput* _output;
 
        bool _handleExceptions;
 
        void missingArgsException();
 
        bool _emptyCombined(const std::string& s);
 
        void deleteOnExit(Arg* ptr);
 
        void deleteOnExit(Visitor* ptr);
 
private:
 
        CmdLine(const CmdLine& rhs);
        CmdLine& operator=(const CmdLine& rhs);
 
        void _constructor();
 
 
        bool _userSetOutput;
 
        bool _helpAndVersion;
 
    public:
 
        CmdLine(const std::string& message,
                const char delimiter = ' ',
                const std::string& version = "none",
                bool helpAndVersion = true);
 
        virtual ~CmdLine();
 
        void add( Arg& a );
 
        void add( Arg* a );
 
        void xorAdd( Arg& a, Arg& b );
 
        void xorAdd( std::vector<Arg*>& xors );
 
        void parse(int argc, const char * const * argv);
 
        void parse(std::vector<std::string>& args);
 
        CmdLineOutput* getOutput();
 
        void setOutput(CmdLineOutput* co);
 
        std::string& getVersion();
 
        std::string& getProgramName();
 
        std::list<Arg*>& getArgList();
 
        XorHandler& getXorHandler();
 
        char getDelimiter();
 
        std::string& getMessage();
 
        bool hasHelpAndVersion();
 
        void setExceptionHandling(const bool state);
 
        bool getExceptionHandling() const;
 
        void reset();
 
};
 
 
//Begin CmdLine.cpp
 
inline CmdLine::CmdLine(const std::string& m,
                        char delim,
                        const std::string& v,
                        bool help )
    :
  _argList(std::list<Arg*>()),
  _progName("not_set_yet"),
  _message(m),
  _version(v),
  _numRequired(0),
  _delimiter(delim),
  _xorHandler(XorHandler()),
  _argDeleteOnExitList(std::list<Arg*>()),
  _visitorDeleteOnExitList(std::list<Visitor*>()),
  _output(0),
  _handleExceptions(true),
  _userSetOutput(false),
  _helpAndVersion(help)
{
    _constructor();
}
 
inline CmdLine::~CmdLine()
{
    ClearContainer(_argDeleteOnExitList);
    ClearContainer(_visitorDeleteOnExitList);
 
    if ( !_userSetOutput ) {
        delete _output;
        _output = 0;
    }
}
 
inline void CmdLine::_constructor()
{
    _output = new StdOutput;
 
    Arg::setDelimiter( _delimiter );
 
    Visitor* v;
 
    if ( _helpAndVersion )
    {
        v = new HelpVisitor( this, &_output );
        SwitchArg* help = new SwitchArg("h","help",
                              "Displays usage information and exits.",
                              false, v);
        add( help );
        deleteOnExit(help);
        deleteOnExit(v);
 
        v = new VersionVisitor( this, &_output );
        SwitchArg* vers = new SwitchArg("","version",
                              "Displays version information and exits.",
                              false, v);
        add( vers );
        deleteOnExit(vers);
        deleteOnExit(v);
    }
 
    v = new IgnoreRestVisitor();
    SwitchArg* ignore  = new SwitchArg(Arg::flagStartString(),
              Arg::ignoreNameString(),
              "Ignores the rest of the labeled arguments following this flag.",
              false, v);
    add( ignore );
    deleteOnExit(ignore);
    deleteOnExit(v);
}
 
inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
{
    _xorHandler.add( ors );
 
    for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
    {
        (*it)->forceRequired();
        (*it)->setRequireLabel( "OR required" );
        add( *it );
    }
}
 
inline void CmdLine::xorAdd( Arg& a, Arg& b )
{
    std::vector<Arg*> ors;
    ors.push_back( &a );
    ors.push_back( &b );
    xorAdd( ors );
}
 
inline void CmdLine::add( Arg& a )
{
    add( &a );
}
 
inline void CmdLine::add( Arg* a )
{
    for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
        if ( *a == *(*it) )
            throw( SpecificationException(
                    "Argument with same flag/name already exists!",
                    a->longID() ) );
 
    a->addToList( _argList );
 
    if ( a->isRequired() )
        _numRequired++;
}
 
 
inline void CmdLine::parse(int argc, const char * const * argv)
{
        // this step is necessary so that we have easy access to
        // mutable strings.
        std::vector<std::string> args;
        for (int i = 0; i < argc; i++)
            args.push_back(argv[i]);
 
        parse(args);
}
 
inline void CmdLine::parse(std::vector<std::string>& args)
{
    bool shouldExit = false;
    int estat = 0;
 
    try {
        _progName = args.front();
        args.erase(args.begin());
 
        int requiredCount = 0;
 
        for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++) 
        {
            bool matched = false;
            for (ArgListIterator it = _argList.begin();
                 it != _argList.end(); it++) {
                if ( (*it)->processArg( &i, args ) )
                {
                    requiredCount += _xorHandler.check( *it );
                    matched = true;
                    break;
                }
            }
 
            // checks to see if the argument is an empty combined
            // switch and if so, then we've actually matched it
            if ( !matched && _emptyCombined( args[i] ) )
                matched = true;
 
            if ( !matched && !Arg::ignoreRest() )
                throw(CmdLineParseException("Couldn't find match "
                                            "for argument",
                                            args[i]));
        }
 
        if ( requiredCount < _numRequired )
            missingArgsException();
 
        if ( requiredCount > _numRequired )
            throw(CmdLineParseException("Too many arguments!"));
 
    } catch ( ArgException& e ) {
        // If we're not handling the exceptions, rethrow.
        if ( !_handleExceptions) {
            throw;
        }
 
        try {
            _output->failure(*this,e);
        } catch ( ExitException &ee ) {
            estat = ee.getExitStatus();
            shouldExit = true;
        }
    } catch (ExitException &ee) {
        // If we're not handling the exceptions, rethrow.
        if ( !_handleExceptions) {
            throw;
        }
 
        estat = ee.getExitStatus();
        shouldExit = true;
    }
 
    if (shouldExit)
        exit(estat);
}
 
inline bool CmdLine::_emptyCombined(const std::string& s)
{
    if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
        return false;
 
    for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
        if ( s[i] != Arg::blankChar() )
            return false;
 
    return true;
}
 
inline void CmdLine::missingArgsException()
{
        int count = 0;
 
        std::string missingArgList;
        for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
        {
            if ( (*it)->isRequired() && !(*it)->isSet() )
            {
                missingArgList += (*it)->getName();
                missingArgList += ", ";
                count++;
            }
        }
        missingArgList = missingArgList.substr(0,missingArgList.length()-2);
 
        std::string msg;
        if ( count > 1 )
            msg = "Required arguments missing: ";
        else
            msg = "Required argument missing: ";
 
        msg += missingArgList;
 
        throw(CmdLineParseException(msg));
}
 
inline void CmdLine::deleteOnExit(Arg* ptr)
{
    _argDeleteOnExitList.push_back(ptr);
}
 
inline void CmdLine::deleteOnExit(Visitor* ptr)
{
    _visitorDeleteOnExitList.push_back(ptr);
}
 
inline CmdLineOutput* CmdLine::getOutput()
{
    return _output;
}
 
inline void CmdLine::setOutput(CmdLineOutput* co)
{
    if ( !_userSetOutput )
        delete _output;
    _userSetOutput = true;
    _output = co;
}
 
inline std::string& CmdLine::getVersion()
{
    return _version;
}
 
inline std::string& CmdLine::getProgramName()
{
    return _progName;
}
 
inline std::list<Arg*>& CmdLine::getArgList()
{
    return _argList;
}
 
inline XorHandler& CmdLine::getXorHandler()
{
    return _xorHandler;
}
 
inline char CmdLine::getDelimiter()
{
    return _delimiter;
}
 
inline std::string& CmdLine::getMessage()
{
    return _message;
}
 
inline bool CmdLine::hasHelpAndVersion()
{
    return _helpAndVersion;
}
 
inline void CmdLine::setExceptionHandling(const bool state)
{
    _handleExceptions = state;
}
 
inline bool CmdLine::getExceptionHandling() const
{
    return _handleExceptions;
}
 
inline void CmdLine::reset()
{
    for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
        (*it)->reset();
    
    _progName.clear();
}
 
//End CmdLine.cpp
 
 
 
} //namespace TCLAP
#endif