An Object Finite Element Library

CmdLine.h

/******************************************************************************
 *
 *  file:  CmdLine.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  All rights reverved.
 *
 *  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 <string>
#include <vector>
#include <list>
#include <iostream>
#include <iomanip>
#include <algorithm>

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

#ifndef DOXYGEN_SHOULD_SKIP_THIS

namespace TCLAP {

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 _emptyCombined(const std::string& s);

                        void deleteOnExit(Arg* ptr);

                        void deleteOnExit(Visitor* ptr);

            private:

                        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, char** argv);

                        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();
};


//Begin CmdLine.cpp

inline CmdLine::CmdLine(const std::string& m,
                                                        char delim,
                                                                        const std::string& v,
                                                                        bool help )
: _progName("not_set_yet"),
  _message(m),
  _version(v),
  _numRequired(0),
  _delimiter(delim),
  _userSetOutput(false),
  _helpAndVersion(help)
{
            _constructor();
}

inline CmdLine::~CmdLine()
{
            ArgListIterator argIter;
            VisitorListIterator visIter;

            for( argIter = _argDeleteOnExitList.begin();
                         argIter != _argDeleteOnExitList.end();
                         ++argIter)
                        delete *argIter;

            for( visIter = _visitorDeleteOnExitList.begin();
                         visIter != _visitorDeleteOnExitList.end();
                         ++visIter)
                        delete *visIter;

            if ( !_userSetOutput )
                        delete _output;
}

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, char** argv)
{
            try {

            _progName = argv[0];

            // this step is necessary so that we have easy access to mutable strings.
            std::vector<std::string> args;
    int i;
            for ( i = 1; i < argc; i++)
                        args.push_back(argv[i]);

            int requiredCount = 0;

            for ( 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 )
                        throw(CmdLineParseException("One or more required arguments missing!"));

            if ( requiredCount > _numRequired )
                        throw(CmdLineParseException("Too many arguments!"));

            } catch ( ArgException e ) { _output->failure(*this,e); exit(1); }
}

inline bool CmdLine::_emptyCombined(const std::string& s)
{
            if ( 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::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)
{
            _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;
}

//End CmdLine.cpp



} //namespace TCLAP
#endif
/* DOXYGEN_SHOULD_SKIP_THIS */

#endif

Copyright © 1998-2007 Rachid Touzani