tclap  1.2.1
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