Parse the options passed to a program. More...

#include <OptionParser.h>

Collaboration diagram for OptionParser:

Public Member Functions
void	addMode (const std::string &modeName)
	Add a mode in the option. More...

template<typename T >
void	addOption (const std::string &longOption, const std::string &shortOption, const std::list< T > &defaultValue, const std::string &docString="")
	Add an option in the OptionParser. More...

template<typename T >
void	addOption (const std::string &longOption, const std::string &shortOption, const std::list< T > &defaultValue, OptionType::OptionType optionType, const std::string &docString="")
	Add an option in the OptionParser. More...

template<typename T >
void	addOption (const std::string &longOption, const std::string &shortOption, const std::vector< T > &defaultValue, const std::string &docString="")
	Add an option in the OptionParser. More...

template<typename T >
void	addOption (const std::string &longOption, const std::string &shortOption, const std::vector< T > &defaultValue, OptionType::OptionType optionType, const std::string &docString="")
	Add an option in the OptionParser. More...

template<typename T >
void	addOption (const std::string &longOption, const std::string &shortOption, const T defaultValue, const std::string &docString="")
	Add an option in the OptionParser. More...

template<typename T >
void	addOption (const std::string &longOption, const std::string &shortOption, const T defaultValue, OptionType::OptionType optionType, const std::string &docString="")
	Add an option in the OptionParser. More...

void	addOption (const std::string &longOption, const std::string &shortOption, OptionType::OptionType optionType, bool isRequired, bool isAllowEmpty, const std::string &docString)
	Add an option in the OptionParser. More...

void	addOption (const std::string &longOption, const std::string &shortOption, OptionType::OptionType optionType, bool isRequired, const std::string &docString)
	Add an option in the OptionParser. More...

void	closeMode ()
	Close the current mode and go back to be default one. More...

OptionMode &	getDefaultMode ()

const OptionMode &	getDefaultMode () const
	Get default mode. More...

OptionMode &	getMode (const std::string &name)
	Get mode by name. More...

const OptionMode &	getMode (const std::string &name) const
	Get mode by name. More...

bool	isModeExist (const std::string &name) const
	Check if the given mode name does exist. More...

OptionParser &	operator= (const OptionParser &other)
	Definition of equal operator of OptionParser. More...

	OptionParser (bool enableHelpOption=true, const std::string &programVersion="")
	Default constructeur of OptionParser. More...

	OptionParser (const OptionParser &other)
	Copy constructor of OptionParser. More...

void	parseArgument (int argc, char **argv)
	Parse the arguments passed to the program. More...

void	print () const
	Print all the options. More...

void	setExampleLongOption (const std::string &example)
	Set the example usage of the program. More...

void	setExampleShortOption (const std::string &example)
	Set the example usage of the program. More...

virtual	~OptionParser ()
	Destructeur of OptionParser. More...

Protected Member Functions
void	copyOptionParser (const OptionParser &other)
	Copy function of OptionParser. More...

Private Member Functions
bool	checkArgument () const
	Check the argument of the parser. More...

template<typename T >
void	checkOptionType (OptionType::OptionType optionType)
	Check the given option type. More...

bool	completeOptionValue (std::string &possibleValue, const std::string &cursorOption, const std::string &prevCursorOption) const
	Complete the possible value of an option (FILENAME, DIRECTORY, FILE_OR_DIR) More...

const OptionMode *	getCurrentlyParsedMode () const
	Get the currently parsed OptionMode. More...

const Option *	getLongOptionValue (std::string &valueToBeCompleted, const std::string &cursorOption) const
	Get the long option value to be completed. More...

OptionMode &	getParserMode (ArgParser &parser)
	Get a mode if it exist. More...

void	getPossibleOption (std::string &possibleOption, const std::string &cursorOption) const
	Get the possible options which can be used. More...

void	getPossibleOtherOption (std::string &possibleOption, const std::string &cursorOption) const
	Get the possible other options which can be used. More...

const Option *	getSplitOptionValue (std::string &valueToBeCompleted, const std::string &cursorOption, const std::string &prevCursorOption) const
	Get the split option (without =) value to be completed. More...

void	initialisationOptionParser ()
	Initialisation function of the class OptionParser. More...

void	parseArgumentBashCompletion (ArgParser &parser)
	Bash completion argument parsing mode. More...

void	parseArgumentNormalUse (ArgParser &parser)
	Classical argument parsing mode. More...

Private Attributes
size_t	p_currentMode
	Index of the current mode in the OptionParser. More...

OptionMode *	p_currentParserMode
	Current mode parsed. More...

bool	p_enableHelpOption
	True to enable automatically the printing of the help option when the program is called with –help or -h. More...

std::string	p_exempleLongOption
	Usage example with long options. More...

std::string	p_exempleShortOption
	Usage example with short options. More...

std::string	p_programVersion
	Program version to be printed on –version or -v option. More...

VecMode	p_vecMode
	Vector of all the defined mode in the OptionParser. More...

Detailed Description

Parse the options passed to a program.

When you define an option, you do not have to pass the '-' of the option name exampe : –longoption or -shortoption you pass only longoption and shortoption

Definition at line 15 of file OptionParser.h.

Constructor & Destructor Documentation

◆ OptionParser() [1/2]

OptionParser::OptionParser	(	bool	enableHelpOption = `true`,
		const std::string &	programVersion = `""`
	)

Default constructeur of OptionParser.

Parameters

enableHelpOption	: True to enable automatically the printing of the help option when the program is called with –help or -h
programVersion	: version of the program to be printed on –version or -v options

Definition at line 16 of file OptionParser.cpp.

         :p_enableHelpOption(enableHelpOption), p_programVersion(programVersion)
 {
         initialisationOptionParser();
 }

References initialisationOptionParser().

Here is the call graph for this function:

◆ OptionParser() [2/2]

OptionParser::OptionParser ( const OptionParser & other )

Copy constructor of OptionParser.

Parameters

other : class to copy

Definition at line 25 of file OptionParser.cpp.

                                                     {
         copyOptionParser(other);
 }

References copyOptionParser().

Here is the call graph for this function:

◆ ~OptionParser()

OptionParser::~OptionParser ( )

virtual

Destructeur of OptionParser.

Definition at line 30 of file OptionParser.cpp.

                            {
         
 }

Member Function Documentation

◆ addMode()

void OptionParser::addMode ( const std::string & modeName )

Add a mode in the option.

Parameters

modeName : name of the new mode to be added

Definition at line 56 of file OptionParser.cpp.

                                                     {
         OptionMode mode(modeName);
         mode.setEnableHelpOption(p_enableHelpOption);
         mode.setProgramVersion(p_programVersion);
         p_vecMode.push_back(mode);
         p_currentMode = p_vecMode.size() - 1lu;
 }

References p_currentMode, p_enableHelpOption, p_programVersion, p_vecMode, OptionMode::setEnableHelpOption(), and OptionMode::setProgramVersion().

Here is the call graph for this function:

◆ addOption() [1/8]

template<typename T >

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		const std::list< T > &	defaultValue,
		const std::string &	docString = `""`
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
defaultValue	: default value of the option
docString	: documentation string of the option The type of the option will be automatically determined with the type of the default value

Definition at line 75 of file OptionParser_impl.h.

                                                                                                                                                      {
         OptionType::OptionType optionType = getOptionTypeFromType<T>();
         OptionValue valueList;
         valueList.setType(optionType);
         valueList.setDefaultValue(defaultValue);
         Option option(longOption, shortOption, valueList, false, docString);
         p_vecMode.back().addOption(option);
 }

References p_vecMode, OptionValue::setDefaultValue(), and OptionValue::setType().

Here is the call graph for this function:

◆ addOption() [2/8]

template<typename T >

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		const std::list< T > &	defaultValue,
		OptionType::OptionType	optionType,
		const std::string &	docString = `""`
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
defaultValue	: default value of the option
optionType	: type of the data of the option (int, float, double, string, etc)
docString	: documentation string of the option The function will check if the given optionType is relevant with the type of the default value

Definition at line 113 of file OptionParser_impl.h.

 {
         checkOptionType<T>(optionType);
         OptionValue valueList;
         valueList.setDefaultValue(defaultValue);
         valueList.setType(optionType);
         Option option(longOption, shortOption, valueList, false, docString);
         p_vecMode.back().addOption(option);
 }

References p_vecMode, OptionValue::setDefaultValue(), and OptionValue::setType().

Here is the call graph for this function:

◆ addOption() [3/8]

template<typename T >

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		const std::vector< T > &	defaultValue,
		const std::string &	docString = `""`
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
defaultValue	: default value of the option
docString	: documentation string of the option The type of the option will be automatically determined with the type of the default value

Definition at line 58 of file OptionParser_impl.h.

                                                                                                                                                        {
         OptionType::OptionType optionType = getOptionTypeFromType<T>();
         OptionValue valueVec;
         valueVec.setType(optionType);
         valueVec.setDefaultValue(defaultValue);
         Option option(longOption, shortOption, valueVec, false, docString);
         p_vecMode.back().addOption(option);
 }

References p_vecMode, OptionValue::setDefaultValue(), and OptionValue::setType().

Here is the call graph for this function:

◆ addOption() [4/8]

template<typename T >

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		const std::vector< T > &	defaultValue,
		OptionType::OptionType	optionType,
		const std::string &	docString = `""`
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
defaultValue	: default value of the option
optionType	: type of the data of the option (int, float, double, string, etc)
docString	: documentation string of the option The function will check if the given optionType is relevant with the type of the default value

Definition at line 93 of file OptionParser_impl.h.

 {
         checkOptionType<T>(optionType);
         OptionValue valueVec;
         valueVec.setDefaultValue(defaultValue);
         valueVec.setType(optionType);
         Option option(longOption, shortOption, valueVec, false, docString);
         p_vecMode.back().addOption(option);
 }

References p_vecMode, OptionValue::setDefaultValue(), and OptionValue::setType().

Here is the call graph for this function:

◆ addOption() [5/8]

template<typename T >

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		const T	defaultValue,
		const std::string &	docString = `""`
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
defaultValue	: default value of the option
docString	: documentation string of the option The type of the option will be automatically determined with the type of the default value

Definition at line 21 of file OptionParser_impl.h.

                                                                                                                                           {
         OptionType::OptionType optionType = getOptionTypeFromType<T>();
         OptionValue value;
         value.setType(optionType);
         value.setDefaultValue(defaultValue);
         Option option(longOption, shortOption, value, false, docString);
         p_vecMode.back().addOption(option);
 }

References p_vecMode, OptionValue::setDefaultValue(), and OptionValue::setType().

Here is the call graph for this function:

◆ addOption() [6/8]

template<typename T >

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		const T	defaultValue,
		OptionType::OptionType	optionType,
		const std::string &	docString = `""`
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
defaultValue	: default value of the option
optionType	: type of the data of the option (int, float, double, string, etc)
docString	: documentation string of the option The function will check if the given optionType is relevant with the type of the default value

Definition at line 39 of file OptionParser_impl.h.

 {
         checkOptionType<T>(optionType);
         OptionValue value;
         value.setType(optionType);
         value.setDefaultValue(defaultValue);
         Option option(longOption, shortOption, value, false, docString);
         p_vecMode.back().addOption(option);
 }

References p_vecMode, OptionValue::setDefaultValue(), and OptionValue::setType().

Here is the call graph for this function:

◆ addOption() [7/8]

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		OptionType::OptionType	optionType,
		bool	isRequired,
		bool	isAllowEmpty,
		const std::string &	docString
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
optionType	: type of the value to be parsed (INT, BOOL_ CHAR, FLOAT, STRING, FILENAME, DIRECTORY, etc)
isRequired	: true if the option is required, false if it is optionnal
isAllowEmpty	: the given value can be empty
docString	: documentation string of the option

Definition at line 94 of file OptionParser.cpp.

 {
         OptionValue value;
         value.setType(optionType);
         Option option(longOption, shortOption, value, isRequired, docString);
         option.setIsAllowEmpty(isAllowEmpty);
         p_vecMode[p_currentMode].addOption(option);
 }

References p_currentMode, p_vecMode, Option::setIsAllowEmpty(), and OptionValue::setType().

Here is the call graph for this function:

◆ addOption() [8/8]

void OptionParser::addOption	(	const std::string &	longOption,
		const std::string &	shortOption,
		OptionType::OptionType	optionType,
		bool	isRequired,
		const std::string &	docString
	)

Add an option in the OptionParser.

Parameters

longOption	: long option (start with –) as –version
shortOption	: short option (start with -) as -v
optionType	: type of the value to be parsed (INT, BOOL_ CHAR, FLOAT, STRING, FILENAME, DIRECTORY, etc)
isRequired	: true if the option is required, false if it is optionnal
docString	: documentation string of the option

Definition at line 76 of file OptionParser.cpp.

 {
         OptionValue value;
         value.setType(optionType);
         Option option(longOption, shortOption, value, isRequired, docString);
         option.setIsAllowEmpty(false);
         p_vecMode[p_currentMode].addOption(option);
 }

References p_currentMode, p_vecMode, Option::setIsAllowEmpty(), and OptionValue::setType().

Here is the call graph for this function:

◆ checkArgument()

bool OptionParser::checkArgument ( ) const

private

Check the argument of the parser.

Returns: true if all the required arguments are set, false otherwise

Definition at line 292 of file OptionParser.cpp.

                                       {
         bool isArgOk(true);
         VecMode::const_iterator it(p_vecMode.begin());
         while(it != p_vecMode.end() && isArgOk){
                 isArgOk = it->checkArgument();
                 ++it;
         }
         return isArgOk;
 }

References p_vecMode.

Referenced by parseArgumentNormalUse().

Here is the caller graph for this function:

◆ checkOptionType()

template<typename T >

void OptionParser::checkOptionType ( OptionType::OptionType optionType )

private

Check the given option type.

Parameters

optionType : type of the option to be checked Throw an exception if there is a problem

Definition at line 129 of file OptionParser_impl.h.

                                                                  {
         OptionType::OptionType optionTypeFromDefault = getOptionTypeFromType<T>();
         if(!isOptionTypeCompatible(optionType, optionTypeFromDefault)){
                 std::stringstream strError;
                 strError << "OptionParser::checkOptionType : Incompatible types from parameters (" << convertOptionTypeToString(optionType) << ") ad for default type ("<<convertOptionTypeToString(optionTypeFromDefault)<<")";
                 throw std::runtime_error(strError.str());
         }
 }

References convertOptionTypeToString(), and isOptionTypeCompatible().

Here is the call graph for this function:

◆ closeMode()

void OptionParser::closeMode ( )

Close the current mode and go back to be default one.

Definition at line 65 of file OptionParser.cpp.

                             {
         p_currentMode = 0lu;
 }

References p_currentMode.

◆ completeOptionValue()

bool OptionParser::completeOptionValue	(	std::string &	possibleValue,
		const std::string &	cursorOption,
		const std::string &	prevCursorOption
	)		const

private

Complete the possible value of an option (FILENAME, DIRECTORY, FILE_OR_DIR)

Parameters

[out]	possibleValue	: possible value
	cursorOption	: option of the cursor which is currently completed
	prevCursorOption	: previous option of the cursor

Definition at line 338 of file OptionParser.cpp.

                                                                                                                                          {
 //      std::cerr << "OptionParser::completeOptionValue : cursorOption = '"<<cursorOption<<"', prevCursorOption = '"<<prevCursorOption<<"'" << std::endl;
         std::string valueToBeCompleted("");
         //Check is the cursor option starts with a long option (--option=value) because the value can be completed
         const Option * op = getLongOptionValue(valueToBeCompleted, cursorOption);
         if(op == NULL){         //Check is the previous option corresponds to an existing option, to complete the value given by the current option
                 op = getSplitOptionValue(valueToBeCompleted, cursorOption, prevCursorOption);
         }
         if(op != NULL){
                 op->getPossibleValue(possibleValue, valueToBeCompleted);
 //              std::cerr << "OptionParser::completeOptionValue : possibleValue = '"<<possibleValue<<"'" << std::endl;
                 return true;
         }
         return false;
 }

References getLongOptionValue(), Option::getPossibleValue(), and getSplitOptionValue().

Referenced by parseArgumentBashCompletion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyOptionParser()

void OptionParser::copyOptionParser ( const OptionParser & other )

protected

Copy function of OptionParser.

Parameters

other : class to copy

Definition at line 191 of file OptionParser.cpp.

                                                              {
         p_vecMode = other.p_vecMode;
         p_currentMode = other.p_currentMode;
         p_exempleShortOption = other.p_exempleShortOption;
         p_exempleLongOption = other.p_exempleLongOption;
         p_programVersion = other.p_programVersion;
         p_enableHelpOption = other.p_enableHelpOption;
 }

References p_currentMode, p_enableHelpOption, p_exempleLongOption, p_exempleShortOption, p_programVersion, and p_vecMode.

Referenced by operator=(), and OptionParser().

Here is the caller graph for this function:

◆ getCurrentlyParsedMode()

const OptionMode * OptionParser::getCurrentlyParsedMode ( ) const

private

Get the currently parsed OptionMode.

Returns: pointer to the currently parsed OptionMode, it there is one, or NULL is there is not

Definition at line 321 of file OptionParser.cpp.

                                                              {
         const OptionMode * mode = NULL;
         VecMode::const_iterator it(p_vecMode.begin());
         while(it != p_vecMode.end() && mode == NULL){
                 if(it->isCurrentlyParsed() && it->getName() != ""){
                         mode = &(*it);
                 }
                 ++it;
         }
         return mode;
 }

References p_vecMode.

Referenced by getPossibleOption().

Here is the caller graph for this function:

◆ getDefaultMode() [1/2]

OptionMode& OptionParser::getDefaultMode ( )

◆ getDefaultMode() [2/2]

OptionMode & OptionParser::getDefaultMode ( ) const

Get default mode.

Returns: default mode

Definition at line 137 of file OptionParser.cpp.

                                                      {
         return p_vecMode[0lu];
 }

References p_vecMode.

Referenced by getMode().

Here is the caller graph for this function:

◆ getLongOptionValue()

const Option * OptionParser::getLongOptionValue	(	std::string &	valueToBeCompleted,
		const std::string &	cursorOption
	)		const

private

Get the long option value to be completed.

Parameters

[out]	valueToBeCompleted	: base of the value to be completed
	cursorOption	: option of the cursor which is currently completed

Returns: pointer to the Option to be completed or NULL if there is not

Definition at line 359 of file OptionParser.cpp.

                                                                                                                    {
         if(cursorOption == ""){return NULL;}
         const Option * op = NULL;
         VecMode::const_iterator itMode(p_vecMode.begin());
         while(itMode != p_vecMode.end() && op == NULL){
                 if(itMode->isCurrentlyParsed()){
                         const VecOption & vecOp = itMode->getVecOption();
                         VecOption::const_iterator itOp(vecOp.begin());
                         while(itOp != vecOp.end() && op == NULL){
                                 std::string fullOp("--" + itOp->getLongName() + "=");
                                 if(isSameBegining(cursorOption, fullOp)){
                                         op = &(*itOp);
                                         valueToBeCompleted = cursorOption.substr(fullOp.size());
                                 }
                                 ++itOp;
                         }
                 }
                 ++itMode;
         }
         return op;
 }

References isSameBegining(), and p_vecMode.

Referenced by completeOptionValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getMode() [1/2]

OptionMode & OptionParser::getMode ( const std::string & name )

Get mode by name.

Parameters

name	: name of the mode to be returned

Returns: corresponding mode if the mode exists or the default mode otherwise

Definition at line 165 of file OptionParser.cpp.

                                                         {
         for(VecMode::iterator it(p_vecMode.begin()); it != p_vecMode.end(); ++it){
                 if(it->getName() == name){
                         return *it;
                 }
         }
         return getDefaultMode();
 }

References getDefaultMode(), and p_vecMode.

Here is the call graph for this function:

◆ getMode() [2/2]

const OptionMode & OptionParser::getMode ( const std::string & name ) const

Get mode by name.

Parameters

name	: name of the mode to be returned

Returns: corresponding mode if the mode exists or the default mode otherwise

Definition at line 152 of file OptionParser.cpp.

                                                                     {
         for(VecMode::const_iterator it(p_vecMode.begin()); it != p_vecMode.end(); ++it){
                 if(it->getName() == name){
                         return *it;
                 }
         }
         return getDefaultMode();
 }

References getDefaultMode(), and p_vecMode.

Referenced by getParserMode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getParserMode()

OptionMode & OptionParser::getParserMode ( ArgParser & parser )

private

Get a mode if it exist.

Parameters

parser : parser to be used

Returns: corresponding mode

Definition at line 306 of file OptionParser.cpp.

                                                           {
         std::string currentOption(parser.getCurrentOption());
         if(isModeExist(currentOption)){
                 OptionMode & mode = getMode(currentOption);
                 p_currentParserMode = &mode;
                 parser.getNextOption();
                 return mode;
         }else{
                 return *p_currentParserMode;
         }
 }

References getMode(), isModeExist(), p_currentParserMode, and createReleaseCurl::parser.

Referenced by parseArgumentNormalUse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPossibleOption()

void OptionParser::getPossibleOption	(	std::string &	possibleOption,
		const std::string &	cursorOption
	)		const

private

Get the possible options which can be used.

Parameters

[out]	possibleOption	: possible options for the bash completion
	cursorOption	: option of the cursor which is currently completed

Definition at line 416 of file OptionParser.cpp.

                                                                                                     {
         if(p_vecMode.size() == 1lu){
                 p_vecMode.front().getPossibleOption(possibleOption, cursorOption);
         }else{
                 const OptionMode * currentlyParsedMode = getCurrentlyParsedMode();
                 if(currentlyParsedMode != NULL){
                         currentlyParsedMode->getPossibleOption(possibleOption, cursorOption);
                 }else{
                         for(VecMode::const_iterator itMode = p_vecMode.begin(); itMode != p_vecMode.end(); ++itMode){
                                 itMode->getPossibleMode(possibleOption, cursorOption);
                         }
                 }
         }
 }

References getCurrentlyParsedMode(), OptionMode::getPossibleOption(), and p_vecMode.

Referenced by parseArgumentBashCompletion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPossibleOtherOption()

void OptionParser::getPossibleOtherOption	(	std::string &	possibleOption,
		const std::string &	cursorOption
	)		const

private

Get the possible other options which can be used.

Parameters

[out]	possibleOption	: possible options for the bash completion
	cursorOption	: option of the cursor which is currently completed

Definition at line 435 of file OptionParser.cpp.

                                                                                                          {
         std::vector<std::string> vecOtherOption;
         vecOtherOption.push_back("--help");
         vecOtherOption.push_back("-h");
         vecOtherOption.push_back("--version");
         vecOtherOption.push_back("-v");
         
         for(std::vector<std::string>::iterator it(vecOtherOption.begin()); it != vecOtherOption.end(); ++it){
                 std::string optionStr(*it);
                 if(cursorOption == ""){
                         possibleOption += optionStr + " ";
                 }else{
                         if(isSameBegining(optionStr, cursorOption)){
                                 possibleOption += optionStr + " ";
                         }
                 }
         }
 }

References isSameBegining().

Referenced by parseArgumentBashCompletion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSplitOptionValue()

const Option * OptionParser::getSplitOptionValue	(	std::string &	valueToBeCompleted,
		const std::string &	cursorOption,
		const std::string &	prevCursorOption
	)		const

private

Get the split option (without =) value to be completed.

Parameters

[out]	valueToBeCompleted	: base of the value to be completed
	cursorOption	: option of the cursor which is currently completed
	prevCursorOption	: previous option of the cursor

Returns: pointer to the Option to be completed or NULL if there is not

Definition at line 387 of file OptionParser.cpp.

                                                                                                                                                         {
         if(prevCursorOption == ""){return NULL;}
         const Option * op = NULL;
         VecMode::const_iterator itMode(p_vecMode.begin());
         while(itMode != p_vecMode.end() && op == NULL){
                 if(itMode->isCurrentlyParsed()){                //Search only in the mode which is currently parsed
                         const VecOption & vecOp = itMode->getVecOption();
                         VecOption::const_iterator itOp(vecOp.begin());
                         while(itOp != vecOp.end() && op == NULL){
                                 std::string fullLongOp("--" + itOp->getLongName()), fullShortOption("-" + itOp->getShortName());
                                 if(fullLongOp == prevCursorOption){
                                         op = &(*itOp);
                                         valueToBeCompleted = cursorOption;
                                 }else if(fullShortOption == prevCursorOption){
                                         op = &(*itOp);
                                         valueToBeCompleted = cursorOption;
                                 }
                                 ++itOp;
                         }
                 }
                 ++itMode;
         }
         return op;
 }

References p_vecMode.

Referenced by completeOptionValue().

Here is the caller graph for this function:

◆ initialisationOptionParser()

void OptionParser::initialisationOptionParser ( )

private

Initialisation function of the class OptionParser.

Definition at line 201 of file OptionParser.cpp.

                                              {
         p_currentMode = 0lu;
         p_currentParserMode = NULL;
         OptionMode defaultMode;
         p_vecMode.push_back(defaultMode);
 }

References p_currentMode, p_currentParserMode, and p_vecMode.

Referenced by OptionParser().

Here is the caller graph for this function:

◆ isModeExist()

bool OptionParser::isModeExist ( const std::string & name ) const

Check if the given mode name does exist.

Parameters

name	: name of the mode

Returns: true if the given mode name does exist, false otherwise

Definition at line 178 of file OptionParser.cpp.

                                                           {
         bool isSearch(true);
         VecMode::const_iterator it(p_vecMode.begin());
         while(isSearch && it != p_vecMode.end()){
                 isSearch &= it->getName() != name;
                 ++it;
         }
         return !isSearch;
 }

References p_vecMode.

Referenced by getParserMode().

Here is the caller graph for this function:

◆ operator=()

OptionParser & OptionParser::operator= ( const OptionParser & other )

Definition of equal operator of OptionParser.

Parameters

other : class to copy

Returns: copied class

Definition at line 38 of file OptionParser.cpp.

                                                                   {
         copyOptionParser(other);
         return *this;
 }

References copyOptionParser().

Here is the call graph for this function:

◆ parseArgument()

void OptionParser::parseArgument	(	int	argc,
		char **	argv
	)

Parse the arguments passed to the program.

Parameters

argc	: number of parameters passed to the program
argv	: list of arguments passed to the program

Definition at line 125 of file OptionParser.cpp.

                                                      {
         ArgParser parser(argc, argv);
         if(parser.isBashCompletionMode()){
                 parseArgumentBashCompletion(parser);
         }else{
                 parseArgumentNormalUse(parser);
         }
 }

References parseArgumentBashCompletion(), parseArgumentNormalUse(), and createReleaseCurl::parser.

Here is the call graph for this function:

◆ parseArgumentBashCompletion()

void OptionParser::parseArgumentBashCompletion ( ArgParser & parser )

private

Bash completion argument parsing mode.

Parameters

parser : parser to be used

Definition at line 244 of file OptionParser.cpp.

                                                                 {
         //First step, we parse normally the existing arguments
         std::string cursorOption(parser.getCursorOption());
         std::string prevCursorOption(parser.getPrevCursorOption());
         Option * partialOption = NULL;
         while(!parser.isEndOfOption()){         //We loop to find the option which has not been parsed well
                 bool isSearch(true);
                 VecMode::iterator itMode = p_vecMode.begin();
                 while(!parser.isEndOfOption() && itMode != p_vecMode.end() && isSearch){
                         isSearch = !itMode->parseOption(parser, partialOption);
                         ++itMode;
                 }
                 if(isSearch){           //If no option matches, we go to the next argument
                         parser.getNextOption();
                 }
         }
         //Complete the ongoing option (filename, directory, enum value, etc)
 //      if(partialOption != NULL){              //The option name has no ambiguity but we expect a value
 //              std::string possibleValue("");
 //              partialOption->getPossibleValue(possibleValue, cursorOption);
 //              cout << possibleValue << endl;
 //      }else{
                 //Let's get the mode which is currently parsed
                 //If all the options are fine, we have to show the remaning options. That's the following
                 std::string possibleValue("");
                 if(completeOptionValue(possibleValue, cursorOption, prevCursorOption)){
 //                      saveFileContent("listPossibleValues.txt", possibleValue);
                         std::cout << possibleValue << std::endl;
                 }else{
                         //Then, get the remaning arguments (not parsed yet)
                         std::string possibleOption("");
                         getPossibleOption(possibleOption, cursorOption);
                         getPossibleOtherOption(possibleOption, cursorOption);
                         
 //                      saveFileContent("listPossibleOption.txt", possibleOption);
                         std::cout << possibleOption << std::endl;
                 }
 //      }
         exit(0);
 //      La marche a suivre est assez simple
 //              On renvoie une ligne par argument possible
 //              Si il y en a qu'une seule, elle sera ajouté à la fin de la ligne de commande
 //      DONE : mettre en place un méchanisme pour générer le bash qui appellera le programme différemment
 }

References completeOptionValue(), getPossibleOption(), getPossibleOtherOption(), p_vecMode, and createReleaseCurl::parser.

Referenced by parseArgument().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseArgumentNormalUse()

void OptionParser::parseArgumentNormalUse ( ArgParser & parser )

private

Classical argument parsing mode.

Parameters

parser : parser to be used

Definition at line 211 of file OptionParser.cpp.

                                                            {
         p_currentParserMode = &p_vecMode.front();
         while(!parser.isEndOfOption()){
                 if(p_enableHelpOption){
                         if(parser.getCurrentOption() == "--help" || parser.getCurrentOption() == "-h"){
                                 print();
                                 exit(0);
                         }
                 }
                 if(p_programVersion != ""){
                         if(parser.getCurrentOption() == "--version" || parser.getCurrentOption() == "-v"){
                                 cout << "Program version : " << p_programVersion << endl;
                                 exit(0);
                         }
                 }
                 OptionMode & currentMode = getParserMode(parser);
                 if(!currentMode.parseOption(parser)){
                         std::string modeName(currentMode.getName());
                         std::string modeError("");
                         if(modeName != ""){
                                 modeError = " in mode '"+modeName+"' ";
                         }
                         throw std::runtime_error("OptionParser::parseArgument : unknown option '"+parser.getCurrentOption()+"'" + modeError);
                 }
         }
         if(!checkArgument()){
                 throw std::runtime_error("OptionParser::parseArgument : missing argument");
         }
 }

References checkArgument(), OptionMode::getName(), getParserMode(), p_currentParserMode, p_enableHelpOption, p_programVersion, p_vecMode, OptionMode::parseOption(), createReleaseCurl::parser, and print().

Referenced by parseArgument().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print()

void OptionParser::print ( ) const

Print all the options.

Definition at line 105 of file OptionParser.cpp.

                               {
         if(p_exempleLongOption != "" || p_exempleShortOption != ""){
                 cout << "Usage :" << endl;
                 if(p_exempleLongOption != ""){cout << "\t" << p_exempleLongOption << endl;}
                 if(p_exempleShortOption != ""){cout << "\t" << p_exempleShortOption << endl;}
         }
         cout << "Parameters :" << endl;
         VecMode::const_iterator it(p_vecMode.begin());
         it->print();
         ++it;
         while(it != p_vecMode.end()){
                 it->print();
                 ++it;
         }
 }

References p_exempleLongOption, p_exempleShortOption, and p_vecMode.

Referenced by main(), and parseArgumentNormalUse().

Here is the caller graph for this function:

◆ setExampleLongOption()

void OptionParser::setExampleLongOption ( const std::string & example )

Set the example usage of the program.

Parameters

example : example of usage

Definition at line 46 of file OptionParser.cpp.

46 {p_exempleLongOption = example;}

References p_exempleLongOption.

◆ setExampleShortOption()

void OptionParser::setExampleShortOption ( const std::string & example )

Set the example usage of the program.

Parameters

example : example of usage

Definition at line 51 of file OptionParser.cpp.

51 {p_exempleShortOption = example;}

References p_exempleShortOption.

Member Data Documentation

◆ p_currentMode

size_t OptionParser::p_currentMode

private

Index of the current mode in the OptionParser.

Definition at line 94 of file OptionParser.h.

Referenced by addMode(), addOption(), closeMode(), copyOptionParser(), and initialisationOptionParser().

◆ p_currentParserMode

OptionMode* OptionParser::p_currentParserMode

private

Current mode parsed.

Definition at line 90 of file OptionParser.h.

Referenced by getParserMode(), initialisationOptionParser(), and parseArgumentNormalUse().

◆ p_enableHelpOption

bool OptionParser::p_enableHelpOption

private

True to enable automatically the printing of the help option when the program is called with –help or -h.

Definition at line 100 of file OptionParser.h.

Referenced by addMode(), copyOptionParser(), and parseArgumentNormalUse().

◆ p_exempleLongOption

std::string OptionParser::p_exempleLongOption

private

Usage example with long options.

Definition at line 96 of file OptionParser.h.

Referenced by copyOptionParser(), print(), and setExampleLongOption().

◆ p_exempleShortOption

std::string OptionParser::p_exempleShortOption

private

Usage example with short options.

Definition at line 98 of file OptionParser.h.

Referenced by copyOptionParser(), print(), and setExampleShortOption().

◆ p_programVersion

std::string OptionParser::p_programVersion

private

Program version to be printed on –version or -v option.

Definition at line 102 of file OptionParser.h.

Referenced by addMode(), copyOptionParser(), and parseArgumentNormalUse().

◆ p_vecMode

VecMode OptionParser::p_vecMode

private

Vector of all the defined mode in the OptionParser.

Definition at line 92 of file OptionParser.h.

Referenced by addMode(), addOption(), checkArgument(), copyOptionParser(), getCurrentlyParsedMode(), getDefaultMode(), getLongOptionValue(), getMode(), getPossibleOption(), getSplitOptionValue(), initialisationOptionParser(), isModeExist(), parseArgumentBashCompletion(), parseArgumentNormalUse(), and print().

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

/builds/CTA-LAPP/PHOENIX_LIBS/PhoenixMock/tmp_project/OptionParser/src/OptionParser.h
/builds/CTA-LAPP/PHOENIX_LIBS/PhoenixMock/tmp_project/OptionParser/src/OptionParser.cpp
/builds/CTA-LAPP/PHOENIX_LIBS/PhoenixMock/tmp_project/OptionParser/src/OptionParser_impl.h

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ OptionParser() [1/2]

◆ OptionParser() [2/2]

◆ ~OptionParser()

Member Function Documentation

◆ addMode()

◆ addOption() [1/8]

◆ addOption() [2/8]

◆ addOption() [3/8]

◆ addOption() [4/8]

◆ addOption() [5/8]

◆ addOption() [6/8]

◆ addOption() [7/8]

◆ addOption() [8/8]

◆ checkArgument()

◆ checkOptionType()

◆ closeMode()

◆ completeOptionValue()

◆ copyOptionParser()

◆ getCurrentlyParsedMode()

◆ getDefaultMode() [1/2]

◆ getDefaultMode() [2/2]

◆ getLongOptionValue()

◆ getMode() [1/2]

◆ getMode() [2/2]

◆ getParserMode()

◆ getPossibleOption()

◆ getPossibleOtherOption()

◆ getSplitOptionValue()

◆ initialisationOptionParser()

◆ isModeExist()

◆ operator=()

◆ parseArgument()

◆ parseArgumentBashCompletion()

◆ parseArgumentNormalUse()

◆ print()

◆ setExampleLongOption()

◆ setExampleShortOption()

Member Data Documentation

◆ p_currentMode

◆ p_currentParserMode

◆ p_enableHelpOption

◆ p_exempleLongOption

◆ p_exempleShortOption

◆ p_programVersion

◆ p_vecMode