CmdLine.h
Go to the documentation of this file.
00001 // -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
00002 
00003 /******************************************************************************
00004  *
00005  *  file:  CmdLine.h
00006  *
00007  *  Copyright (c) 2003, Michael E. Smoot .
00008  *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
00009  *  All rights reverved.
00010  *
00011  *  See the file COPYING in the top directory of this distribution for
00012  *  more information.
00013  *
00014  *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
00015  *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00016  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
00017  *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00018  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
00019  *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
00020  *  DEALINGS IN THE SOFTWARE.
00021  *
00022  *****************************************************************************/
00023 
00024 #ifndef TCLAP_CMDLINE_H
00025 #define TCLAP_CMDLINE_H
00026 
00027 #include <tclap/SwitchArg.h>
00028 #include <tclap/MultiSwitchArg.h>
00029 #include <tclap/UnlabeledValueArg.h>
00030 #include <tclap/UnlabeledMultiArg.h>
00031 
00032 #include <tclap/XorHandler.h>
00033 #include <tclap/HelpVisitor.h>
00034 #include <tclap/VersionVisitor.h>
00035 #include <tclap/IgnoreRestVisitor.h>
00036 
00037 #include <tclap/CmdLineOutput.h>
00038 #include <tclap/StdOutput.h>
00039 
00040 #include <tclap/Constraint.h>
00041 #include <tclap/ValuesConstraint.h>
00042 
00043 #include <string>
00044 #include <vector>
00045 #include <list>
00046 #include <iostream>
00047 #include <iomanip>
00048 #include <algorithm>
00049 #include <stdlib.h> // Needed for exit(), which isn't defined in some envs.
00050 
00051 namespace TCLAP {
00052 
00053 template<typename T> void DelPtr(T ptr)
00054 {
00055         delete ptr;
00056 }
00057 
00058 template<typename C> void ClearContainer(C &c)
00059 {
00060         typedef typename C::value_type value_type;
00061         std::for_each(c.begin(), c.end(), DelPtr<value_type>);
00062         c.clear();
00063 }
00064 
00065 
00070 class CmdLine : public CmdLineInterface
00071 {
00072         protected:
00073 
00078                 std::list<Arg*> _argList;
00079 
00083                 std::string _progName;
00084 
00088                 std::string _message;
00089 
00093                 std::string _version;
00094 
00100                 int _numRequired;
00101 
00106                 char _delimiter;
00107 
00111                 XorHandler _xorHandler;
00112 
00118                 std::list<Arg*> _argDeleteOnExitList;
00119 
00125                 std::list<Visitor*> _visitorDeleteOnExitList;
00126 
00130                 CmdLineOutput* _output;
00131 
00135                 bool _handleExceptions;
00136 
00140                 void missingArgsException();
00141 
00148                 bool _emptyCombined(const std::string& s);
00149 
00153                 void deleteOnExit(Arg* ptr);
00154 
00158                 void deleteOnExit(Visitor* ptr);
00159 
00160 private:
00161 
00165                 CmdLine(const CmdLine& rhs);
00166                 CmdLine& operator=(const CmdLine& rhs);
00167 
00172                 void _constructor();
00173 
00174 
00179                 bool _userSetOutput;
00180 
00184                 bool _helpAndVersion;
00185 
00186         public:
00187 
00200                 CmdLine(const std::string& message,
00201                                 const char delimiter = ' ',
00202                                 const std::string& version = "none",
00203                                 bool helpAndVersion = true);
00204 
00208                 virtual ~CmdLine();
00209 
00214                 void add( Arg& a );
00215 
00220                 void add( Arg* a );
00221 
00228                 void xorAdd( Arg& a, Arg& b );
00229 
00235                 void xorAdd( std::vector<Arg*>& xors );
00236 
00242                 void parse(int argc, const char * const * argv);
00243 
00249                 void parse(std::vector<std::string>& args);
00250 
00254                 CmdLineOutput* getOutput();
00255 
00259                 void setOutput(CmdLineOutput* co);
00260 
00264                 std::string& getVersion();
00265 
00269                 std::string& getProgramName();
00270 
00274                 std::list<Arg*>& getArgList();
00275 
00279                 XorHandler& getXorHandler();
00280 
00284                 char getDelimiter();
00285 
00289                 std::string& getMessage();
00290 
00294                 bool hasHelpAndVersion();
00295 
00301                 void setExceptionHandling(const bool state);
00302 
00309                 bool getExceptionHandling() const;
00310 
00314                 void reset();
00315 
00316 };
00317 
00318 
00320 //Begin CmdLine.cpp
00322 
00323 inline CmdLine::CmdLine(const std::string& m,
00324                         char delim,
00325                         const std::string& v,
00326                         bool help )
00327     :
00328   _argList(std::list<Arg*>()),
00329   _progName("not_set_yet"),
00330   _message(m),
00331   _version(v),
00332   _numRequired(0),
00333   _delimiter(delim),
00334   _xorHandler(XorHandler()),
00335   _argDeleteOnExitList(std::list<Arg*>()),
00336   _visitorDeleteOnExitList(std::list<Visitor*>()),
00337   _output(0),
00338   _handleExceptions(true),
00339   _userSetOutput(false),
00340   _helpAndVersion(help)
00341 {
00342         _constructor();
00343 }
00344 
00345 inline CmdLine::~CmdLine()
00346 {
00347         ClearContainer(_argDeleteOnExitList);
00348         ClearContainer(_visitorDeleteOnExitList);
00349 
00350         if ( !_userSetOutput ) {
00351                 delete _output;
00352                 _output = 0;
00353         }
00354 }
00355 
00356 inline void CmdLine::_constructor()
00357 {
00358         _output = new StdOutput;
00359 
00360         Arg::setDelimiter( _delimiter );
00361 
00362         Visitor* v;
00363 
00364         if ( _helpAndVersion )
00365         {
00366                 v = new HelpVisitor( this, &_output );
00367                 SwitchArg* help = new SwitchArg("h","help",
00368                                       "Displays usage information and exits.",
00369                                       false, v);
00370                 add( help );
00371                 deleteOnExit(help);
00372                 deleteOnExit(v);
00373 
00374                 v = new VersionVisitor( this, &_output );
00375                 SwitchArg* vers = new SwitchArg("","version",
00376                                       "Displays version information and exits.",
00377                                       false, v);
00378                 add( vers );
00379                 deleteOnExit(vers);
00380                 deleteOnExit(v);
00381         }
00382 
00383         v = new IgnoreRestVisitor();
00384         SwitchArg* ignore  = new SwitchArg(Arg::flagStartString(),
00385                   Arg::ignoreNameString(),
00386                   "Ignores the rest of the labeled arguments following this flag.",
00387                   false, v);
00388         add( ignore );
00389         deleteOnExit(ignore);
00390         deleteOnExit(v);
00391 }
00392 
00393 inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
00394 {
00395         _xorHandler.add( ors );
00396 
00397         for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
00398         {
00399                 (*it)->forceRequired();
00400                 (*it)->setRequireLabel( "OR required" );
00401                 add( *it );
00402         }
00403 }
00404 
00405 inline void CmdLine::xorAdd( Arg& a, Arg& b )
00406 {
00407         std::vector<Arg*> ors;
00408         ors.push_back( &a );
00409         ors.push_back( &b );
00410         xorAdd( ors );
00411 }
00412 
00413 inline void CmdLine::add( Arg& a )
00414 {
00415         add( &a );
00416 }
00417 
00418 inline void CmdLine::add( Arg* a )
00419 {
00420         for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
00421                 if ( *a == *(*it) )
00422                         throw( SpecificationException(
00423                                 "Argument with same flag/name already exists!",
00424                                 a->longID() ) );
00425 
00426         a->addToList( _argList );
00427 
00428         if ( a->isRequired() )
00429                 _numRequired++;
00430 }
00431 
00432 
00433 inline void CmdLine::parse(int argc, const char * const * argv)
00434 {
00435                 // this step is necessary so that we have easy access to
00436                 // mutable strings.
00437                 std::vector<std::string> args;
00438                 for (int i = 0; i < argc; i++)
00439                         args.push_back(argv[i]);
00440 
00441                 parse(args);
00442 }
00443 
00444 inline void CmdLine::parse(std::vector<std::string>& args)
00445 {
00446         bool shouldExit = false;
00447         int estat = 0;
00448 
00449         try {
00450                 _progName = args.front();
00451                 args.erase(args.begin());
00452 
00453                 int requiredCount = 0;
00454 
00455                 for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++) 
00456                 {
00457                         bool matched = false;
00458                         for (ArgListIterator it = _argList.begin();
00459                              it != _argList.end(); it++) {
00460                                 if ( (*it)->processArg( &i, args ) )
00461                                 {
00462                                         requiredCount += _xorHandler.check( *it );
00463                                         matched = true;
00464                                         break;
00465                                 }
00466                         }
00467 
00468                         // checks to see if the argument is an empty combined
00469                         // switch and if so, then we've actually matched it
00470                         if ( !matched && _emptyCombined( args[i] ) )
00471                                 matched = true;
00472 
00473                         if ( !matched && !Arg::ignoreRest() )
00474                                 throw(CmdLineParseException("Couldn't find match "
00475                                                             "for argument",
00476                                                             args[i]));
00477                 }
00478 
00479                 if ( requiredCount < _numRequired )
00480                         missingArgsException();
00481 
00482                 if ( requiredCount > _numRequired )
00483                         throw(CmdLineParseException("Too many arguments!"));
00484 
00485         } catch ( ArgException& e ) {
00486                 // If we're not handling the exceptions, rethrow.
00487                 if ( !_handleExceptions) {
00488                         throw;
00489                 }
00490 
00491                 try {
00492                         _output->failure(*this,e);
00493                 } catch ( ExitException &ee ) {
00494                         estat = ee.getExitStatus();
00495                         shouldExit = true;
00496                 }
00497         } catch (ExitException &ee) {
00498                 // If we're not handling the exceptions, rethrow.
00499                 if ( !_handleExceptions) {
00500                         throw;
00501                 }
00502 
00503                 estat = ee.getExitStatus();
00504                 shouldExit = true;
00505         }
00506 
00507         if (shouldExit)
00508                 exit(estat);
00509 }
00510 
00511 inline bool CmdLine::_emptyCombined(const std::string& s)
00512 {
00513         if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
00514                 return false;
00515 
00516         for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
00517                 if ( s[i] != Arg::blankChar() )
00518                         return false;
00519 
00520         return true;
00521 }
00522 
00523 inline void CmdLine::missingArgsException()
00524 {
00525                 int count = 0;
00526 
00527                 std::string missingArgList;
00528                 for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
00529                 {
00530                         if ( (*it)->isRequired() && !(*it)->isSet() )
00531                         {
00532                                 missingArgList += (*it)->getName();
00533                                 missingArgList += ", ";
00534                                 count++;
00535                         }
00536                 }
00537                 missingArgList = missingArgList.substr(0,missingArgList.length()-2);
00538 
00539                 std::string msg;
00540                 if ( count > 1 )
00541                         msg = "Required arguments missing: ";
00542                 else
00543                         msg = "Required argument missing: ";
00544 
00545                 msg += missingArgList;
00546 
00547                 throw(CmdLineParseException(msg));
00548 }
00549 
00550 inline void CmdLine::deleteOnExit(Arg* ptr)
00551 {
00552         _argDeleteOnExitList.push_back(ptr);
00553 }
00554 
00555 inline void CmdLine::deleteOnExit(Visitor* ptr)
00556 {
00557         _visitorDeleteOnExitList.push_back(ptr);
00558 }
00559 
00560 inline CmdLineOutput* CmdLine::getOutput()
00561 {
00562         return _output;
00563 }
00564 
00565 inline void CmdLine::setOutput(CmdLineOutput* co)
00566 {
00567         if ( !_userSetOutput )
00568                 delete _output;
00569         _userSetOutput = true;
00570         _output = co;
00571 }
00572 
00573 inline std::string& CmdLine::getVersion()
00574 {
00575         return _version;
00576 }
00577 
00578 inline std::string& CmdLine::getProgramName()
00579 {
00580         return _progName;
00581 }
00582 
00583 inline std::list<Arg*>& CmdLine::getArgList()
00584 {
00585         return _argList;
00586 }
00587 
00588 inline XorHandler& CmdLine::getXorHandler()
00589 {
00590         return _xorHandler;
00591 }
00592 
00593 inline char CmdLine::getDelimiter()
00594 {
00595         return _delimiter;
00596 }
00597 
00598 inline std::string& CmdLine::getMessage()
00599 {
00600         return _message;
00601 }
00602 
00603 inline bool CmdLine::hasHelpAndVersion()
00604 {
00605         return _helpAndVersion;
00606 }
00607 
00608 inline void CmdLine::setExceptionHandling(const bool state)
00609 {
00610         _handleExceptions = state;
00611 }
00612 
00613 inline bool CmdLine::getExceptionHandling() const
00614 {
00615         return _handleExceptions;
00616 }
00617 
00618 inline void CmdLine::reset()
00619 {
00620         for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
00621                 (*it)->reset();
00622         
00623         _progName.clear();
00624 }
00625 
00627 //End CmdLine.cpp
00629 
00630 
00631 
00632 } //namespace TCLAP
00633 #endif


mapstitch
Author(s): Philipp M. Scholl
autogenerated on Mon Oct 6 2014 02:09:52