#include <Optionpk.h>

Inheritance diagram for Optionpk< T >:

Collaboration diagram for Optionpk< T >:

Public Member Functions
	Optionpk ()
	default constructor

	Optionpk (const std::string &shortName, const std::string &longName, const std::string &helpInfo)
	constructor for option without default value More...

	Optionpk (const std::string &shortName, const std::string &longName, const std::string &helpInfo, const T &defaultValue, short hide=0)
	constructor for option with default value. Option can be hidden for help info More...

	~Optionpk ()
	default destructor

void	setHelp (const std::string &helpInfo)
	set help information

void	setHide (short hide)
	hide option from short help -h (1) or make invisible to short and long help –help (2)

bool	retrieveOption (int argc, const std::vector< std::string > &argv)
	read option from command line (use for all options!), std::string implementation More...

bool	retrieveOption (int argc, char **argv)
	read option from command line (use for all options!) More...

void	setAll (const std::string &shortName, const std::string &longName, const std::string &helpInfo)
	set all attributes of the option, except default and hide

void	setAll (const std::string &shortName, const std::string &longName, const std::string &helpInfo, const T &defaultValue, short hide)
	set all attributes of the option

void	setDefault (const T &defaultValue)
	set a default value for the option

std::string	getDefaultValue () const

void	setShortName (const std::string &shortName)
	set the short name to be used as -shortName

void	setLongName (const std::string &longName)
	set the long name to be used as –longName

std::string	getShortName () const
	get the short name to be used as -shortName

std::string	getLongName () const
	get the long name to be used as –longName

std::string	getHelp () const
	get help info stored in m_help

std::vector< T >::const_iterator	findSubstring (const T &argument) const

template<>
void	setAll (const std::string &shortName, const std::string &longName, const std::string &helpInfo)
	specialization for bool

template<>
void	setAll (const std::string &shortName, const std::string &longName, const std::string &helpInfo, const bool &defaultValue, short hide)
	specialization for bool

template<>
	Optionpk (const std::string &shortName, const std::string &longName, const std::string &helpInfo)
	specialization for bool

template<>
	Optionpk (const std::string &shortName, const std::string &longName, const std::string &helpInfo, const bool &defaultValue, short hide)
	specialization for bool

template<>
std::vector< std::string >::const_iterator	findSubstring (const std::string &argument) const

Static Public Member Functions
static std::string	getGPLv3License ()
	get license info

Friends
template<class T1 >
std::ostream &	operator<< (std::ostream &os, const Optionpk< T1 > &theOption)
	print values for this option

Detailed Description

template<class T>
class Optionpk< T >

Class to implement command line options. With the constructor you can define an option, in both short - and long -- format, of a specific type, help information and a default value.
This class inherits from std::vector, so the option variable is a vector, supporting multiple inputs for the same option (e.g., –input file1 [–input file2 ...]. Several command line option formats are supported:

-shortOption value
-shortOption=value
--longOption value
--longOption=value
-shortOption (no value for boolean options, which are automatically set by invoking the option)
--longOption (no value for boolean options, which are automatically set by invoking the option)

Option names should have regular characters and no white space in them. Some names are reserved and can not be used either:

short option h or long option help: shows usage
long option help shows long help info
long option license: shows license info
long option version: shows current version of pktools
long option doxygen: shows help info in table format, ready to be included in doxygen

A call to member function retrieveOption reads the command line arguments and initializes the object (vector). Make sure to call this member function before using the option object in your main program (or a segmentation error due to an un-initialized vector will occur).

All calls to retrieveOption should reside in a try{} block. If one of the reserved options

license
version is used, an exception of type std::string is thrown. This can be caught with a catch(string predefinedString) right after the try block, where the message can be sent to stdout and the program can be ended.

Similarly, if help is invoked with the short option -h or long option --help, the main program is informed by the return value false of retrieveOption (for any option). An example how to use Optionpk is shown in pktestOption.cc

Definition at line 106 of file Optionpk.h.

Constructor & Destructor Documentation

◆ Optionpk() [1/2]

template<class T >

Optionpk< T >::Optionpk	(	const std::string &	shortName,
		const std::string &	longName,
		const std::string &	helpInfo
	)

inline

constructor for option without default value

constructor without default value
shortName is option invoked with -
longName is option invoked with --
helpInfo is the help message that is shown when option -h or –help is invoked

Definition at line 211 of file Optionpk.h.

 : m_hasDefault(false)
 {
   setAll(shortName,longName,helpInfo);
 }

◆ Optionpk() [2/2]

template<class T >

Optionpk< T >::Optionpk	(	const std::string &	shortName,
		const std::string &	longName,
		const std::string &	helpInfo,
		const T &	defaultValue,
		short	hide = `0`
	)

inline

constructor for option with default value. Option can be hidden for help info

constructor with default value.
shortName is option invoked with -
longName is option invoked with --
helpInfo is the help message that is shown when option -h or –help is invoked
defaultValue is default value of the option (first value of vector: option[0])
hide=0 : option is visible for in both short (-h). Typical use: mandatory options
hide=1 : option is only visible in long help (--help). Typical use: expert options
hide=2 : option is hidden for user. Typical use: Easter eggs or options only known to author

Definition at line 227 of file Optionpk.h.

 {
   setAll(shortName,longName,helpInfo,defaultValue, hide);
 }

Member Function Documentation

◆ findSubstring()

template<class T>

std::vector<T>::const_iterator Optionpk< T >::findSubstring ( const T & argument ) const

inline

find substring in options of type string (e.g., -co INTERLEAVE=BAND) this template function only makes sense for T=std::string (implemented via a specialization)

Definition at line 162 of file Optionpk.h.

162 {std::string errorString="Error: findSubstring only defined for options of type std::string"; throw(errorString);};

◆ retrieveOption() [1/2]

template<class T >

bool Optionpk< T >::retrieveOption	(	int	argc,
		const std::vector< std::string > &	argv
	)

inline

read option from command line (use for all options!), std::string implementation

make sure to call this function first before using the option in main program (or segmentation fault will occur...)

Definition at line 311 of file Optionpk.h.

                                                                                                    {
   bool noHelp=true;//return value, alert main program that hard coded option (help, version, license, doxygen) was invoked
   std::string helpStringShort="-h";//short option for help (hard coded)
   std::string helpStringLong="--help";//long option for help (hard coded)
   std::string helpStringDoxygen="--doxygen";//option to create table of options ready to use for doxygen
   std::string versionString="--version";//option to show current version
   std::string licenseString="--license";//option to show current version
   for(int i = 1; i < argc; ++i ){
     std::string currentArgument;
     std::string currentOption=argv[i];
     std::string shortOption=m_shortName;
     std::string longOption=m_longName;
     shortOption.insert(0,"-");
     longOption.insert(0,"--");
     size_t foundEqual=currentOption.rfind("=");
     if(foundEqual!=std::string::npos){
       currentArgument=currentOption.substr(foundEqual+1);
       currentOption=currentOption.substr(0,foundEqual);
     }
     if(!helpStringShort.compare(currentOption)){
       if(m_hide<1)
         std::cout << usage() << std::endl;
       noHelp=false;
     }
     else if(!helpStringLong.compare(currentOption)){
       if(m_hide<2)
         std::cout << usage() << std::endl;
       noHelp=false;
     }
     else if(!helpStringDoxygen.compare(currentOption)){
       if(m_hide<2)
         std::cout << usageDoxygen() << std::endl;
       noHelp=false;
     }
     else if(!versionString.compare(currentOption)){
       std::string theVersion="version ";
       theVersion+=VERSION;
       theVersion+=", Copyright (C) Pieter Kempeneers.\n\
    This program comes with ABSOLUTELY NO WARRANTY; for details type use option -h.\n \
    This is free software, and you are welcome to redistribute it\n      \
    under certain conditions; use option --license for details.";
       throw(theVersion);//no need to continue registering (break prevents from multiplication of version info)
     }
     else if(!licenseString.compare(currentOption)){
       throw(getGPLv3License());
     }
     if(hasShortOption()&&!(shortOption.compare(currentOption))){//for -option
       if(foundEqual!=std::string::npos)
         this->push_back(string2type<T>(currentArgument));
       else if(m_hasArgument && i < argc-1)
         this->push_back(string2type<T>(argv[++i]));
       else
         this->push_back(string2type<T>("1"));
     }
     else if(hasLongOption()&&!(longOption.compare(currentOption))){//for --option
       if(foundEqual!=std::string::npos)
         this->push_back(string2type<T>(currentArgument));
       else if(m_hasArgument && i < argc-1)
         this->push_back(string2type<T>(argv[++i]));
       else
         this->push_back(string2type<T>("1"));
     }
   }
   if(!(this->size())&&m_hasDefault)//only set default value if no options were given
     this->push_back(m_defaultValue);
   return(noHelp);
 }

◆ retrieveOption() [2/2]

template<class T >

bool Optionpk< T >::retrieveOption	(	int	argc,
		char **	argv
	)

inline

read option from command line (use for all options!)

make sure to call this function first before using the option in main program (or segmentation fault will occur...)

Definition at line 382 of file Optionpk.h.

                                                                               { 
   bool noHelp=true;//return value, alert main program that hard coded option (help, version, license, doxygen) was invoked
   std::string helpStringShort="-h";//short option for help (hard coded)
   std::string helpStringLong="--help";//long option for help (hard coded)
   std::string helpStringDoxygen="--doxygen";//option to create table of options ready to use for doxygen
   std::string versionString="--version";//option to show current version
   std::string licenseString="--license";//option to show current version
   for(int i = 1; i < argc; ++i ){
     std::string currentArgument;
     std::string currentOption=argv[i];
     std::string shortOption=m_shortName;
     std::string longOption=m_longName;
     shortOption.insert(0,"-");
     longOption.insert(0,"--");
     size_t foundEqual=currentOption.rfind("=");
     if(foundEqual!=std::string::npos){
       currentArgument=currentOption.substr(foundEqual+1);
       currentOption=currentOption.substr(0,foundEqual);
     }
     if(!helpStringShort.compare(currentOption)){
       if(m_hide<1)
         std::cout << usage() << std::endl;
       noHelp=false;
     }
     else if(!helpStringLong.compare(currentOption)){
       if(m_hide<2)
         std::cout << usage() << std::endl;
       noHelp=false;
     }
     else if(!helpStringDoxygen.compare(currentOption)){
       if(m_hide<2)
         std::cout << usageDoxygen() << std::endl;
       noHelp=false;
     }
     else if(!versionString.compare(currentOption)){
       std::string theVersion="version ";
       theVersion+=VERSION;
       theVersion+=", Copyright (C) Pieter Kempeneers.\n\
    This program comes with ABSOLUTELY NO WARRANTY; for details type use option -h.\n \
    This is free software, and you are welcome to redistribute it\n      \
    under certain conditions; use option --license for details.";
       throw(theVersion);//no need to continue registering (break prevents from multiplication of version info)
     }
     else if(!licenseString.compare(currentOption)){
       throw(getGPLv3License());
     }
     if(hasShortOption()&&!(shortOption.compare(currentOption))){//for -option
       if(foundEqual!=std::string::npos)
         this->push_back(string2type<T>(currentArgument));
       else if(m_hasArgument && i < argc-1)
         this->push_back(string2type<T>(argv[++i]));
       else
         this->push_back(string2type<T>("1"));
     }
     else if(hasLongOption()&&!(longOption.compare(currentOption))){//for --option
       if(foundEqual!=std::string::npos)
         this->push_back(string2type<T>(currentArgument));
       else if(m_hasArgument && i < argc-1)
         this->push_back(string2type<T>(argv[++i]));
       else
         this->push_back(string2type<T>("1"));
     }
   }
   if(!(this->size())&&m_hasDefault)//only set default value if no options were given
     this->push_back(m_defaultValue);
   return(noHelp);
 }

The documentation for this class was generated from the following file:

/home/kempepi/PKTOOLS-2.6.7.6/src/base/Optionpk.h

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

template<class T> class Optionpk< T >

Constructor & Destructor Documentation

◆ Optionpk() [1/2]

◆ Optionpk() [2/2]

Member Function Documentation

◆ findSubstring()

◆ retrieveOption() [1/2]

◆ retrieveOption() [2/2]

template<class T>
class Optionpk< T >