CmdLine.h
Go to the documentation of this file.
1 // -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
2 
3 /******************************************************************************
4  *
5  * file: CmdLine.h
6  *
7  * Copyright (c) 2003, Michael E. Smoot .
8  * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
9  * All rights reverved.
10  *
11  * See the file COPYING in the top directory of this distribution for
12  * more information.
13  *
14  * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20  * DEALINGS IN THE SOFTWARE.
21  *
22  *****************************************************************************/
23 
24 #ifndef TCLAP_CMDLINE_H
25 #define TCLAP_CMDLINE_H
26 
27 #include <tclap/SwitchArg.h>
28 #include <tclap/MultiSwitchArg.h>
31 
32 #include <tclap/XorHandler.h>
33 #include <tclap/HelpVisitor.h>
34 #include <tclap/VersionVisitor.h>
36 
37 #include <tclap/CmdLineOutput.h>
38 #include <tclap/StdOutput.h>
39 
40 #include <tclap/Constraint.h>
41 #include <tclap/ValuesConstraint.h>
42 
43 #include <string>
44 #include <vector>
45 #include <list>
46 #include <iostream>
47 #include <iomanip>
48 #include <algorithm>
49 #include <stdlib.h> // Needed for exit(), which isn't defined in some envs.
50 
51 namespace TCLAP {
52 
53 template<typename T> void DelPtr(T ptr)
54 {
55  delete ptr;
56 }
57 
58 template<typename C> void ClearContainer(C &c)
59 {
60  typedef typename C::value_type value_type;
61  std::for_each(c.begin(), c.end(), DelPtr<value_type>);
62  c.clear();
63 }
64 
65 
70 class CmdLine : public CmdLineInterface
71 {
72  protected:
73 
78  std::list<Arg*> _argList;
79 
84 
89 
94 
100  int _numRequired;
101 
106  char _delimiter;
107 
112 
118  std::list<Arg*> _argDeleteOnExitList;
119 
125  std::list<Visitor*> _visitorDeleteOnExitList;
126 
131 
135  bool _handleExceptions;
136 
140  void missingArgsException();
141 
148  bool _emptyCombined(const std::string& s);
149 
153  void deleteOnExit(Arg* ptr);
154 
158  void deleteOnExit(Visitor* ptr);
159 
160 private:
161 
165  CmdLine(const CmdLine& rhs);
166  CmdLine& operator=(const CmdLine& rhs);
167 
172  void _constructor();
173 
174 
179  bool _userSetOutput;
180 
184  bool _helpAndVersion;
185 
186  public:
187 
200  CmdLine(const std::string& message,
201  const char delimiter = ' ',
202  const std::string& version = "none",
203  bool helpAndVersion = true);
204 
208  virtual ~CmdLine();
209 
214  void add( Arg& a );
215 
220  void add( Arg* a );
221 
228  void xorAdd( Arg& a, Arg& b );
229 
235  void xorAdd( std::vector<Arg*>& xors );
236 
242  void parse(int argc, const char * const * argv);
243 
249  void parse(std::vector<std::string>& args);
250 
255 
259  void setOutput(CmdLineOutput* co);
260 
265 
270 
274  std::list<Arg*>& getArgList();
275 
280 
284  char getDelimiter();
285 
290 
294  bool hasHelpAndVersion();
295 
301  void setExceptionHandling(const bool state);
302 
309  bool getExceptionHandling() const;
310 
314  void reset();
315 
316 };
317 
318 
320 //Begin CmdLine.cpp
322 
323 inline CmdLine::CmdLine(const std::string& m,
324  char delim,
325  const std::string& v,
326  bool help )
327  :
328  _argList(std::list<Arg*>()),
329  _progName("not_set_yet"),
330  _message(m),
331  _version(v),
332  _numRequired(0),
333  _delimiter(delim),
334  _xorHandler(XorHandler()),
335  _argDeleteOnExitList(std::list<Arg*>()),
336  _visitorDeleteOnExitList(std::list<Visitor*>()),
337  _output(0),
338  _handleExceptions(true),
339  _userSetOutput(false),
340  _helpAndVersion(help)
341 {
343 }
344 
345 inline CmdLine::~CmdLine()
346 {
349 
350  if ( !_userSetOutput ) {
351  delete _output;
352  _output = 0;
353  }
354 }
355 
356 inline void CmdLine::_constructor()
357 {
358  _output = new StdOutput;
359 
361 
362  Visitor* v;
363 
365  {
366  v = new HelpVisitor( this, &_output );
367  SwitchArg* help = new SwitchArg("h","help",
368  "Displays usage information and exits.",
369  false, v);
370  add( help );
372  deleteOnExit(v);
373 
374  v = new VersionVisitor( this, &_output );
375  SwitchArg* vers = new SwitchArg("","version",
376  "Displays version information and exits.",
377  false, v);
378  add( vers );
379  deleteOnExit(vers);
380  deleteOnExit(v);
381  }
382 
383  v = new IgnoreRestVisitor();
384  SwitchArg* ignore = new SwitchArg(Arg::flagStartString(),
386  "Ignores the rest of the labeled arguments following this flag.",
387  false, v);
388  add( ignore );
389  deleteOnExit(ignore);
390  deleteOnExit(v);
391 }
392 
393 inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
394 {
395  _xorHandler.add( ors );
396 
397  for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
398  {
399  (*it)->forceRequired();
400  (*it)->setRequireLabel( "OR required" );
401  add( *it );
402  }
403 }
404 
405 inline void CmdLine::xorAdd( Arg& a, Arg& b )
406 {
407  std::vector<Arg*> ors;
408  ors.push_back( &a );
409  ors.push_back( &b );
410  xorAdd( ors );
411 }
412 
413 inline void CmdLine::add( Arg& a )
414 {
415  add( &a );
416 }
417 
418 inline void CmdLine::add( Arg* a )
419 {
420  for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
421  if ( *a == *(*it) )
422  throw( SpecificationException(
423  "Argument with same flag/name already exists!",
424  a->longID() ) );
425 
426  a->addToList( _argList );
427 
428  if ( a->isRequired() )
429  _numRequired++;
430 }
431 
432 
433 inline void CmdLine::parse(int argc, const char * const * argv)
434 {
435  // this step is necessary so that we have easy access to
436  // mutable strings.
437  std::vector<std::string> args;
438  for (int i = 0; i < argc; i++)
439  args.push_back(argv[i]);
440 
441  parse(args);
442 }
443 
444 inline void CmdLine::parse(std::vector<std::string>& args)
445 {
446  bool shouldExit = false;
447  int estat = 0;
448 
449  try {
450  _progName = args.front();
451  args.erase(args.begin());
452 
453  int requiredCount = 0;
454 
455  for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++)
456  {
457  bool matched = false;
458  for (ArgListIterator it = _argList.begin();
459  it != _argList.end(); it++) {
460  if ( (*it)->processArg( &i, args ) )
461  {
462  requiredCount += _xorHandler.check( *it );
463  matched = true;
464  break;
465  }
466  }
467 
468  // checks to see if the argument is an empty combined
469  // switch and if so, then we've actually matched it
470  if ( !matched && _emptyCombined( args[i] ) )
471  matched = true;
472 
473  if ( !matched && !Arg::ignoreRest() )
474  throw(CmdLineParseException("Couldn't find match "
475  "for argument",
476  args[i]));
477  }
478 
479  if ( requiredCount < _numRequired )
481 
482  if ( requiredCount > _numRequired )
483  throw(CmdLineParseException("Too many arguments!"));
484 
485  } catch ( ArgException& e ) {
486  // If we're not handling the exceptions, rethrow.
487  if ( !_handleExceptions) {
488  throw;
489  }
490 
491  try {
492  _output->failure(*this,e);
493  } catch ( ExitException &ee ) {
494  estat = ee.getExitStatus();
495  shouldExit = true;
496  }
497  } catch (ExitException &ee) {
498  // If we're not handling the exceptions, rethrow.
499  if ( !_handleExceptions) {
500  throw;
501  }
502 
503  estat = ee.getExitStatus();
504  shouldExit = true;
505  }
506 
507  if (shouldExit)
508  exit(estat);
509 }
510 
511 inline bool CmdLine::_emptyCombined(const std::string& s)
512 {
513  if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
514  return false;
515 
516  for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
517  if ( s[i] != Arg::blankChar() )
518  return false;
519 
520  return true;
521 }
522 
523 inline void CmdLine::missingArgsException()
524 {
525  int count = 0;
526 
527  std::string missingArgList;
528  for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
529  {
530  if ( (*it)->isRequired() && !(*it)->isSet() )
531  {
532  missingArgList += (*it)->getName();
533  missingArgList += ", ";
534  count++;
535  }
536  }
537  missingArgList = missingArgList.substr(0,missingArgList.length()-2);
538 
540  if ( count > 1 )
541  msg = "Required arguments missing: ";
542  else
543  msg = "Required argument missing: ";
544 
545  msg += missingArgList;
546 
547  throw(CmdLineParseException(msg));
548 }
549 
550 inline void CmdLine::deleteOnExit(Arg* ptr)
551 {
552  _argDeleteOnExitList.push_back(ptr);
553 }
554 
555 inline void CmdLine::deleteOnExit(Visitor* ptr)
556 {
557  _visitorDeleteOnExitList.push_back(ptr);
558 }
559 
560 inline CmdLineOutput* CmdLine::getOutput()
561 {
562  return _output;
563 }
564 
565 inline void CmdLine::setOutput(CmdLineOutput* co)
566 {
567  if ( !_userSetOutput )
568  delete _output;
570  _output = co;
571 }
572 
574 {
575  return _version;
576 }
577 
579 {
580  return _progName;
581 }
582 
583 inline std::list<Arg*>& CmdLine::getArgList()
584 {
585  return _argList;
586 }
587 
589 {
590  return _xorHandler;
591 }
592 
593 inline char CmdLine::getDelimiter()
594 {
595  return _delimiter;
596 }
597 
599 {
600  return _message;
601 }
602 
603 inline bool CmdLine::hasHelpAndVersion()
604 {
605  return _helpAndVersion;
606 }
607 
608 inline void CmdLine::setExceptionHandling(const bool state)
609 {
611 }
612 
613 inline bool CmdLine::getExceptionHandling() const
614 {
615  return _handleExceptions;
616 }
617 
618 inline void CmdLine::reset()
619 {
620  for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
621  (*it)->reset();
622 
623  _progName.clear();
624 }
625 
627 //End CmdLine.cpp
629 
630 
631 
632 } //namespace TCLAP
633 #endif
TCLAP::CmdLine::~CmdLine
virtual ~CmdLine()
Definition: CmdLine.h:364
TCLAP::SwitchArg
Definition: SwitchArg.h:58
count
GLint GLsizei count
Definition: glad/glad/glad.h:2301
TCLAP::CmdLine::_emptyCombined
bool _emptyCombined(const std::string &s)
Definition: CmdLine.h:530
TCLAP::CmdLine::getExceptionHandling
bool getExceptionHandling() const
Definition: CmdLine.h:632
TCLAP::CmdLine::_numRequired
int _numRequired
Definition: CmdLine.h:119
TCLAP::CmdLine::_argDeleteOnExitList
std::list< Arg * > _argDeleteOnExitList
Definition: CmdLine.h:137
TCLAP::CmdLine
Definition: CmdLine.h:89
TCLAP::CmdLine::getOutput
CmdLineOutput * getOutput()
Definition: CmdLine.h:579
rs2::sw_update::version
rsutils::version version
Definition: versions-db-manager.h:30
MultiSwitchArg.h
b
GLboolean GLboolean GLboolean b
Definition: glad/glad/glad.h:3064
TCLAP::HelpVisitor
Definition: HelpVisitor.h:53
TCLAP::CmdLine::parse
void parse(int argc, const char *const *argv)
Definition: CmdLine.h:452
devices.help
help
Definition: third-party/realdds/scripts/devices.py:6
TCLAP::ArgListIterator
std::list< Arg * >::iterator ArgListIterator
Definition: Arg.h:396
v
GLdouble v
Definition: glad/glad/glad.h:2144
string
GLsizei const GLchar *const * string
Definition: glad/glad/glad.h:2861
Constraint.h
TCLAP::CmdLine::_xorHandler
XorHandler _xorHandler
Definition: CmdLine.h:130
HelpVisitor.h
TCLAP::Arg::flagStartString
static const std::string flagStartString()
Definition: Arg.h:236
TCLAP::DelPtr
void DelPtr(T ptr)
Definition: CmdLine.h:72
TCLAP::CmdLine::setExceptionHandling
void setExceptionHandling(const bool state)
Definition: CmdLine.h:627
TCLAP::CmdLineParseException
Definition: ArgException.h:161
UnlabeledValueArg.h
UnlabeledMultiArg.h
TCLAP::CmdLine::getMessage
std::string & getMessage()
Definition: CmdLine.h:617
TCLAP::ClearContainer
void ClearContainer(C &c)
Definition: CmdLine.h:77
TCLAP::CmdLine::hasHelpAndVersion
bool hasHelpAndVersion()
Definition: CmdLine.h:622
CmdLineOutput.h
TCLAP::Arg::ignoreRest
static bool ignoreRest()
Definition: Arg.h:205
TCLAP::CmdLine::add
void add(Arg &a)
Definition: CmdLine.h:432
TCLAP::Arg::blankChar
static char blankChar()
Definition: Arg.h:217
TCLAP::CmdLine::missingArgsException
void missingArgsException()
Definition: CmdLine.h:542
TCLAP::CmdLine::getVersion
std::string & getVersion()
Definition: CmdLine.h:592
TCLAP::CmdLine::setOutput
void setOutput(CmdLineOutput *co)
Definition: CmdLine.h:584
TCLAP::CmdLine::_userSetOutput
bool _userSetOutput
Definition: CmdLine.h:198
TCLAP::IgnoreRestVisitor
Definition: IgnoreRestVisitor.h:53
TCLAP::CmdLine::CmdLine
CmdLine(const CmdLine &rhs)
StdOutput.h
TCLAP::CmdLine::getDelimiter
char getDelimiter()
Definition: CmdLine.h:612
TCLAP::CmdLine::getArgList
std::list< Arg * > & getArgList()
Definition: CmdLine.h:602
m
std::mutex m
Definition: test-waiting-on.cpp:126
TCLAP::Arg::setDelimiter
static void setDelimiter(char c)
Definition: Arg.h:256
TCLAP::CmdLine::_handleExceptions
bool _handleExceptions
Definition: CmdLine.h:154
TCLAP::CmdLineOutput
Definition: CmdLineOutput.h:59
TCLAP::CmdLine::operator=
CmdLine & operator=(const CmdLine &rhs)
i
int i
Definition: rs-pcl-color.cpp:54
TCLAP::CmdLine::_helpAndVersion
bool _helpAndVersion
Definition: CmdLine.h:203
TCLAP::CmdLine::getXorHandler
XorHandler & getXorHandler()
Definition: CmdLine.h:607
TCLAP::CmdLine::_output
CmdLineOutput * _output
Definition: CmdLine.h:149
TCLAP::ArgVectorIterator
std::vector< Arg * >::iterator ArgVectorIterator
Definition: Arg.h:401
message
GLenum GLuint GLenum GLsizei const GLchar * message
Definition: glad/glad/glad.h:135
TCLAP::CmdLine::_message
std::string _message
Definition: CmdLine.h:107
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glad/glad/glad.h:3064
opencv_pointcloud_viewer.state
state
Definition: opencv_pointcloud_viewer.py:63
TCLAP::CmdLine::_argList
std::list< Arg * > _argList
Definition: CmdLine.h:97
SwitchArg.h
TCLAP::CmdLineOutput::failure
virtual void failure(CmdLineInterface &c, ArgException &e)=0
TCLAP::CmdLine::_visitorDeleteOnExitList
std::list< Visitor * > _visitorDeleteOnExitList
Definition: CmdLine.h:144
XorHandler.h
TCLAP::CmdLine::_progName
std::string _progName
Definition: CmdLine.h:102
TCLAP::XorHandler
Definition: XorHandler.h:57
IgnoreRestVisitor.h
TCLAP::CmdLine::xorAdd
void xorAdd(Arg &a, Arg &b)
Definition: CmdLine.h:424
TCLAP::XorHandler::add
void add(std::vector< Arg * > &ors)
Definition: XorHandler.h:114
TCLAP::Arg::flagStartChar
static char flagStartChar()
Definition: Arg.h:226
realsense_device_manager.c
c
Definition: realsense_device_manager.py:322
TCLAP::Visitor
Definition: Visitor.h:49
TCLAP::CmdLine::_version
std::string _version
Definition: CmdLine.h:112
std
Definition: android_helpers.h:13
TCLAP::CmdLine::deleteOnExit
void deleteOnExit(Arg *ptr)
Definition: CmdLine.h:569
TCLAP::SpecificationException
Definition: ArgException.h:185
state
Definition: rs-measure.cpp:80
rs2::textual_icons::exit
static const textual_icon exit
Definition: device-model.h:222
TCLAP::CmdLine::getProgramName
std::string & getProgramName()
Definition: CmdLine.h:597
VersionVisitor.h
TCLAP::VersionVisitor
Definition: VersionVisitor.h:55
rmse.e
e
Definition: rmse.py:177
ValuesConstraint.h
it
static auto it
Definition: openvino-face-detection.cpp:375
TCLAP::CmdLine::_constructor
void _constructor()
Definition: CmdLine.h:375
TCLAP::Arg::ignoreNameString
static const std::string ignoreNameString()
Definition: Arg.h:250
s
GLdouble s
Definition: glad/glad/glad.h:2441
TCLAP::XorHandler::check
int check(const Arg *a)
Definition: XorHandler.h:119
TCLAP::CmdLine::_delimiter
char _delimiter
Definition: CmdLine.h:125
TCLAP::CmdLine::reset
void reset()
Definition: CmdLine.h:637
TCLAP
Definition: Arg.h:57
test-streaming.msg
msg
Definition: test-streaming.py:51
TCLAP::Arg
Definition: Arg.h:64
devices.args
args
Definition: third-party/realdds/scripts/devices.py:5


librealsense2
Author(s): LibRealSense ROS Team
autogenerated on Fri Aug 2 2024 08:30:01