class that contains the parser, i.e. does that option handling More...

#include <Options.h>

Collaboration diagram for options::parser:

Public Member Functions
	parser (const std::string &aDescription="", const std::string &aTrailer="", const std::vector< std::string > &aSearchPaths={"/etc/", "~/.", "~/.config/", "./."})

	~parser ()

bool	fIsParsingDone () const

void	fSetMessageStream (std::ostream *aStream)

void	fSetErrorStream (std::ostream *aStream)

std::ostream &	fGetErrorStream () const

void	fSetHelpReturnValue (int aValue)

int	fGetHelpReturnValue () const

virtual void	fComplainAndLeave (bool aWithHelp=true)
	print help (if required) and exit. More...

void	fSetAssignmentChars (char aPrimary='=', char aSecondary=':')

char	fGetSecondaryAssignment () const

virtual void	fRequire (const base *aOtherOption)

virtual void	fRequire (std::vector< const base * > aOtherOptions)

const std::vector< std::string > &	fParse (int argc, const char *argv[])
	parse the options on the command line More...

const std::vector< std::string > &	fParse (int argc, char *argv[])
	other signature for fParse, when argv needs to be without const due to external constraints More...

void	fHelp ()
	print help, normally automatically called by the –help option or in case of problems. More...

void	fWriteCfgFile (const std::string &aFileName)

void	fReadCfgFile (const std::string &aFileName, const options::internal::sourceItem &aSource, bool aMayBeAbsent=false)

void	fSetExecutableName (const char *aName)

void	fSetMinusMinusStartsExtraList ()
	switch on use of – to separate a trailer on the command line that is not to be parsed More...

const std::vector< std::string > &	fGetStuffAfterMinusMinus ()
	get trailong part of command line as a vector od strings, requires that fSetMinusMinusStartsExtraList was called before parsing. More...

const std::string &	fGetProgName () const

Static Public Member Functions
static parser *	fGetInstance ()
	get the only allwed instance of the option parser. More...

static void	fPrintEscapedString (std::ostream &aStream, const std::string &aString)

static void	fReCaptureEscapedString (std::string &aDest, const std::string &aSource)

Protected Member Functions
void	fReadConfigFiles ()
	read config files if present More...

void	fPrintOptionHelp (std::ostream &aMessageStream, const base &aOption, std::size_t aMaxName, std::size_t aMaxExplain, size_t lineLenght) const

void	fCheckConsistency ()

Protected Attributes
const std::string	lDescription

const std::string	lTrailer

const std::vector< std::string >	lSearchPaths

std::vector< std::string >	lUnusedOptions

std::vector< std::string >	lStuffAfterMinusMinus

std::set< const base * >	lRequiredOptions

bool	lMinusMinusJustEndsOptions

std::ostream *	lMessageStream

std::ostream *	lErrorStream

std::string	lProgName

std::string	lExecutableName

int	lHelpReturnValue

char	lPrimaryAssignment

char	lSecondaryAssignment

bool	lParsingIsDone

Static Protected Attributes
static parser *	gParser = nullptr

Detailed Description

class that contains the parser, i.e. does that option handling

once contructed with the header part and the trailer part of the help text, together with the list of search paths for config files the option parser can then be used to parse the command line options.

Definition at line 363 of file Options.h.

Constructor & Destructor Documentation

◆ parser()

options::parser::parser	(	const std::string &	aDescription = `""`,
		const std::string &	aTrailer = `""`,
		const std::vector< std::string > &	aSearchPaths = `{"/etc/", "~/.", "~/.config/", "./."}`
	)

Definition at line 90 of file Options.cpp.

                                                                                                                     :
         lDescription(aDescription),
         lTrailer(aTrailer),
         lSearchPaths(aSearchPaths),
         lParsingIsDone(false) {
         if (gParser != nullptr) {
             std::cerr << "there may be only one parser" << std::endl;
             fComplainAndLeave(false);
         }
         gParser = this;
         lErrorStream = &std::cerr;
         lMessageStream = &std::cout;
         lHelpReturnValue = 0;
         fSetAssignmentChars();
         lMinusMinusJustEndsOptions = true;
     }

References fComplainAndLeave(), fSetAssignmentChars(), gParser, lErrorStream, lHelpReturnValue, lMessageStream, and lMinusMinusJustEndsOptions.

Here is the call graph for this function:

◆ ~parser()

options::parser::~parser ( )

Definition at line 106 of file Options.cpp.

                     {
         gParser = nullptr;
     }

References gParser.

Member Function Documentation

◆ fCheckConsistency()

void options::parser::fCheckConsistency ( )

protected

Definition at line 323 of file Options.cpp.

                                    {
         std::set<const base*> optionsThatWereSet;
         for (auto & it : base::fGetOptionMap()) {
             auto opt = it.second;
             if (opt->fIsSet()) {
                 optionsThatWereSet.insert(opt);
             }
         }
         if (! lRequiredOptions.empty()) {
             std::vector<const base*> missing;
             std::set_difference(lRequiredOptions.cbegin(), lRequiredOptions.cend(),
                                 optionsThatWereSet.cbegin(), optionsThatWereSet.cend(),
                                 std::inserter(missing, missing.begin()));
             if (! missing.empty()) {
                 fGetErrorStream() << "The following options are required but were not given:";
                 for (auto opt : missing) {
                     fGetErrorStream() << " " << opt->fGetLongName();
                 }
                 fGetErrorStream() << "\n";
                 fComplainAndLeave();
             }
         }
         for (auto opt : optionsThatWereSet) {
             for (auto forbidden : opt->lForbiddenOptions) {
                 if (optionsThatWereSet.count(forbidden) != 0) {
                     fGetErrorStream() << "The option " << opt->fGetLongName() << " forbids the use of " << forbidden->fGetLongName() << " but it is given.\n";
                     fComplainAndLeave();
                 }
             }
             for (auto required : opt->lRequiredOptions) {
                 if (optionsThatWereSet.count(required) == 0) {
                     fGetErrorStream() << "The option " << opt->fGetLongName() << " requires the use of " << required->fGetLongName() << " but it is not given.\n";
                     fComplainAndLeave();
                 }
             }
         }
     }

References fComplainAndLeave(), fGetErrorStream(), options::base::fGetOptionMap(), and lRequiredOptions.

Referenced by fParse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fComplainAndLeave()

void options::parser::fComplainAndLeave ( bool aWithHelp = true )

virtual

print help (if required) and exit.

this function can be overloaded in a class derived from parser, for example when one instead of calling exit() wants to throw an exception. as normaly the call to exit() is what is required this is the default action.

Definition at line 365 of file Options.cpp.

                                                  {
         if (aWithHelp) {
             fGetErrorStream() << "\nFor complete usage: " << fGetProgName() << " --help\n";
         }
         exit(1);
     }

References fGetErrorStream(), and fGetProgName().

Referenced by fCheckConsistency(), fParse(), options::internal::fParseTimePointString(), options::internal::parseNumberAndUnit(), and parser().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fGetErrorStream()

std::ostream & options::parser::fGetErrorStream ( ) const

Definition at line 121 of file Options.cpp.

                                               {
         return *lErrorStream;
     }

References lErrorStream.

Referenced by fCheckConsistency(), fComplainAndLeave(), fParse(), options::internal::fParseTimePointString(), fReadCfgFile(), and options::internal::parseNumberAndUnit().

Here is the caller graph for this function:

◆ fGetHelpReturnValue()

int options::parser::fGetHelpReturnValue ( ) const

inline

Definition at line 398 of file Options.h.

                                         {
             return lHelpReturnValue;
         };

References lHelpReturnValue.

◆ fGetInstance()

parser * options::parser::fGetInstance ( )

static

get the only allwed instance of the option parser.

Definition at line 144 of file Options.cpp.

                                  {
         return gParser;
     }

References gParser.

Referenced by options::base::base(), options::internal::fParseTimePointString(), options::map< T >::fSetMe(), options::internal::OptionWriteCfgFile::fSetMe(), options::internal::OptionReadCfgFile< mayBeMissing >::fSetMe(), options::internal::OptionHelp::fSetMeNoarg(), options::map< T >::fWriteCfgLines(), options::map< T >::fWriteValue(), and options::internal::parseNumberAndUnit().

Here is the caller graph for this function:

◆ fGetProgName()

const std::string& options::parser::fGetProgName ( ) const

inline

Definition at line 436 of file Options.h.

                                               {
             return lProgName;
         }

References lProgName.

Referenced by fComplainAndLeave().

Here is the caller graph for this function:

◆ fGetSecondaryAssignment()

char options::parser::fGetSecondaryAssignment ( ) const

inline

Definition at line 403 of file Options.h.

                                              {
             return lSecondaryAssignment;
         }

References lSecondaryAssignment.

Referenced by options::map< T >::fWriteCfgLines(), and options::map< T >::fWriteValue().

Here is the caller graph for this function:

◆ fGetStuffAfterMinusMinus()

const std::vector<std::string>& options::parser::fGetStuffAfterMinusMinus ( )

inline

get trailong part of command line as a vector od strings, requires that fSetMinusMinusStartsExtraList was called before parsing.

Definition at line 433 of file Options.h.

                                                                {
             return lStuffAfterMinusMinus;
         };

References lStuffAfterMinusMinus.

Referenced by main().

Here is the caller graph for this function:

◆ fHelp()

void options::parser::fHelp ( )

print help, normally automatically called by the –help option or in case of problems.

Definition at line 724 of file Options.cpp.

                        {
         *lMessageStream << lProgName << ": " << lDescription << "\n";
  
         if (!internal::positional_base::fGetPositonalArgs().empty()) {
             *lMessageStream << "Usage: " << lProgName << " [option]...";
             for (const auto& it : internal::positional_base::fGetPositonalArgs()) {
                 *lMessageStream << " [" << it.second->fGetLongName() << "]";
                 if (it.second->fIsContainer()) {
                     *lMessageStream << "...";
                 }
             }
             *lMessageStream << "\n";
         }
  
         size_t maxName = 0;
         size_t maxExplain = 0;
         size_t lineLenght = 132;
         #ifdef IS_NONBROKEN_SYSTEM
         {
             struct winsize window;
             if (ioctl(0, TIOCGWINSZ, &window) == 0) {
                 lineLenght = window.ws_col;
             }
         }
         #endif
         for (auto & it : base::fGetOptionMap()) {
             const auto opt = it.second;
             maxName = std::max(opt->lLongName.length(), maxName);
             maxExplain = std::max(opt->lExplanation.length(), maxExplain);
         }
         for (auto & it : base::fGetOptionMap()) {
             const auto opt = it.second;
             if (! opt->fIsHidden()) {
                 fPrintOptionHelp(*lMessageStream, *opt, maxName, maxExplain, lineLenght);
             }
         }
         if (!lSearchPaths.empty()) {
             *lMessageStream << "Looking for config files in ";
             for (const auto & searchPath : lSearchPaths) {
                 *lMessageStream << searchPath << " ";
             }
             *lMessageStream << "\n";
         }
  
         *lMessageStream << lTrailer;
         *lMessageStream << std::endl;
     }

References options::base::fGetOptionMap(), options::internal::positional_base::fGetPositonalArgs(), fPrintOptionHelp(), lDescription, lMessageStream, lProgName, lSearchPaths, and lTrailer.

Referenced by options::internal::OptionHelp::fSetMeNoarg(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fIsParsingDone()

bool options::parser::fIsParsingDone ( ) const

Definition at line 110 of file Options.cpp.

                                       {
         return lParsingIsDone;
     }

References lParsingIsDone.

◆ fParse() [1/2]

const std::vector< std::string > & options::parser::fParse	(	int	argc,
		char *	argv[]
	)

other signature for fParse, when argv needs to be without const due to external constraints

Definition at line 164 of file Options.cpp.

                                                                      {
         return fParse(argc, const_cast<const char**>(argv));
     }

References fParse().

Here is the call graph for this function:

◆ fParse() [2/2]

const std::vector< std::string > & options::parser::fParse	(	int	argc,
		const char *	argv[]
	)

parse the options on the command line

The command line is passed via the argc and argv parameres, which will reamain unchanged. Also reads config files, using fReadConfigFiles() and all files which are explicitly requested by –readCfgFile options.

Returns: vector of strings containing all the unhandled string from the original command line

Definition at line 168 of file Options.cpp.

                                                                            {
         if (lParsingIsDone) {
             throw std::logic_error("parsing may be done only once");
         }
         lParsingIsDone = true; // we set this early, as of now now new options may be created
         {
             #ifdef IS_NONBROKEN_SYSTEM
             auto buf = strdup(argv[0]);
             lProgName = basename(buf);
             free(buf);
             #else
             lProgName = argv[0];
             #endif
         }
         bool firstOptionNotSeen = true;
         try {
             for (int i = 1; i < argc; i++) {
                 if (firstOptionNotSeen && !(argv[i][0] == '-' && argv[i][1] == '-' && internal::gOptionNoCfgFiles.lLongName.compare(argv[i] + 2) == 0)) {
                     fReadConfigFiles();
                 }
                 if (argv[i][0] == '-' && argv[i][1] != '-') {
                     auto length = strlen(argv[i]);
                     for (unsigned int j = 1; j < length; j++) {
                         auto it =  base::fGetShortOptionMap().find(argv[i][j]);
                         if (it == base::fGetShortOptionMap().end()) {
                             throw std::runtime_error(internal::conCat("unknown short option '", argv[i][j], "'"));
                         } else {
                             auto opt = it->second;
                             if (opt->lNargs > 0 && strlen(argv[i]) > 2) {
                                 throw internal::optionError(opt, internal::conCat("run-together short options '", argv[i], "'may not use parameters"));
                             }
                             opt->fHandleOption(argc, argv, &i);
                         }
                     }
                 } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] != '-') {
                     auto length = strlen(argv[i]);
                     if (length == 2) { // end of options
                         for (i++; i < argc; i++) {
                             if (lMinusMinusJustEndsOptions) {
                                 lUnusedOptions.push_back(argv[i]);
                             } else {
                                 lStuffAfterMinusMinus.push_back(argv[i]);
                             }
                         }
                         break;
                     } else {
                         if (nullptr == strchr(argv[i], lPrimaryAssignment)) {
                             auto it = base::fGetOptionMap().find(argv[i] + 2);
                             if (it == base::fGetOptionMap().end()) {
                                 throw std::runtime_error(internal::conCat("unknown long option '", argv[i], "'"));
                             }
                             auto opt = it->second;
                             opt->fHandleOption(argc, argv, &i);
                         } else {
                             auto buf = strdup(argv[i]);
                             auto equalsAt = strchr(buf, lPrimaryAssignment);
                             *equalsAt = '\0';
                             auto it = base::fGetOptionMap().find(buf + 2);
                             if (it == base::fGetOptionMap().end()) {
                                 throw std::runtime_error(internal::conCat("unknown long option '", argv[i], "'"));
                             }
                             auto opt = it->second;
                             std::stringstream sbuf(equalsAt + 1);
                             opt->fSetMe(sbuf, internal::sourceItem(&internal::sourceFile::gCmdLine, i));
                             opt->fCheckRange();
                             free(buf);
                         }
                     }
                 } else {
                     lUnusedOptions.push_back(argv[i]);
                 }
                 firstOptionNotSeen = false;
             }
             if (firstOptionNotSeen) { // read cfg files if no options set at all
                 fReadConfigFiles();
             }
  
             if (!internal::positional_base::fGetPositonalArgs().empty()) {
                 std::list<base*> positionalArgs;
                 for (auto it : internal::positional_base::fGetPositonalArgs()) {
                     positionalArgs.push_back(it.second);
                 }
                 while (!lUnusedOptions.empty()) {
                     auto opt = positionalArgs.front();
                     if (opt->fIsContainer()) { // process first options from the back
                         for (;;) {
                             auto opt2 = positionalArgs.back();
                             if (opt2 == opt) {
                                 break;
                             }
                             positionalArgs.pop_back();
                             auto& arg = lUnusedOptions.back();
                             std::stringstream sbuf(arg);
                             opt2->fSetMe(sbuf, internal::sourceItem(&internal::sourceFile::gCmdLine, 0));
                             opt2->fCheckRange();
                             lUnusedOptions.pop_back();
                             if (lUnusedOptions.empty()) {
                                 break;
                             }
                         }
                     }
                     if (lUnusedOptions.empty()) {
                         break;
                     }
                     auto& arg = lUnusedOptions.front();
                     std::stringstream sbuf(arg);
                     opt->fSetMe(sbuf, internal::sourceItem(&internal::sourceFile::gCmdLine, 0));
                     opt->fCheckRange();
                     lUnusedOptions.erase(lUnusedOptions.begin());
                     if (! opt->fIsContainer()) {
                         positionalArgs.pop_front();
                         if (positionalArgs.empty()) {
                             break;
                         }
                     }
                 }
             }
         } catch (const internal::rangeError& e) {
             fGetErrorStream() << e.what() << " in option '" << e.fGetOption().fGetLongName() << "' value '" << e.fGetBadValue() << "'\n";
             e.fGetOption().fWriteRange(fGetErrorStream());
             fComplainAndLeave();
         } catch (const internal::conversionError& e) {
             fGetErrorStream() << e.what() << " in option '" << e.fGetOption().fGetLongName()
                               << "' cannot convert '" << e.fGetArgument() << "' to type '" << e.fGetType().name() << "'\n";
             fComplainAndLeave();
         } catch (const internal::optionError& e) {
             fGetErrorStream() << e.what() << " in option '" << e.fGetOption().fGetLongName() << "'\n";
             fComplainAndLeave();
         } catch (std::exception& e) {
             fGetErrorStream() << e.what() << "\n";
             fComplainAndLeave();
         }
  
  
         if (internal::gOptionDebugOptions) {
             for (auto & it : base::fGetOptionMap()) {
                 auto opt = it.second;
                 fGetErrorStream() << "option " << opt->lLongName << " has value '";
                 opt->fWriteValue(fGetErrorStream());
                 fGetErrorStream() << "' ";
                 if (opt->lSource.fIsUnset()) {
                     fGetErrorStream() << " (default) ";
                 } else {
                     fGetErrorStream() << " from " << opt->lSource;
                 }
                 fGetErrorStream() << std::endl;
             }
             for (auto & unusedOption : lUnusedOptions) {
                 fGetErrorStream() << "unused option '" << unusedOption << "'" << std::endl;
             }
         }
         fCheckConsistency();
         return lUnusedOptions;
     }

Referenced by fParse(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fPrintEscapedString()

void options::parser::fPrintEscapedString	(	std::ostream &	aStream,
		const std::string &	aString
	)

static

Definition at line 376 of file Options.cpp.

                                                                                    {
         bool delimit = aString.find_first_of(" \t,") != std::string::npos;
         if (delimit) {
             aStream << '\'';
         }
         for (auto c : aString) {
             switch (c) {
                 case '\a':
                     aStream << "\\a";
                     break;
                 case '\b':
                     aStream << "\\b";
                     break;
                 case '\f':
                     aStream << "\\f";
                     break;
                 case '\n':
                     aStream << "\\n";
                     break;
                 case '\r':
                     aStream << "\\r";
                     break;
                 case '\t':
                     aStream << "\\t";
                     break;
                 case ' ':
                     aStream << "\\ ";
                     break;
                 case '\v':
                     aStream << "\\v";
                     break;
                 case '\\':
                     aStream << "\\\\";
                     break;
                 case '\'':
                     aStream << "\\\'";
                     break;
                 case '"':
                     aStream << "\\\"";
                     break;
                 default:
                     if (c >= ' ' && c < 127) {
                         aStream << c;
                     } else {
                         aStream << '\\' << std::oct << std::setw(3) << std::setfill('0') << static_cast<unsigned int>(c) << std::setfill(' ') << std::dec;
                     }
             }
         }
         if (delimit) {
             aStream << '\'';
         }
     }

Referenced by options::escapedIO::operator<<().

Here is the caller graph for this function:

◆ fPrintOptionHelp()

void options::parser::fPrintOptionHelp	(	std::ostream &	aMessageStream,
		const base &	aOption,
		std::size_t	aMaxName,
		std::size_t	aMaxExplain,
		size_t	lineLenght
	)		const

protected

Definition at line 646 of file Options.cpp.

                                                                                                                                                      {
         std::size_t fullNameLength = 8 + aMaxName;
         std::size_t descLength = std::min(lineLenght - 20 - fullNameLength, aMaxExplain);
         if (aOption.lShortName != '\0') {
             aMessageStream << "  -" << aOption.lShortName << ", ";
         } else {
             aMessageStream << "      ";
         }
         auto explanation = aOption.lExplanation;
         bool firstLine = true;
         do {
             if (firstLine) {
                 aMessageStream << "--" << std::setw(aMaxName) << std::left << aOption.lLongName
                                << " ";
             } else {
                 aMessageStream << "        " << std::setw(aMaxName) << " " << "  ";
             }
             if (explanation.length() > descLength) {
                 // Need to linebreak.
                 bool keepBrokenChar = false;
                 bool hardBreak = false;
                 auto breakPos = explanation.find_last_of(" -", descLength - 1);
                 if (breakPos == std::string::npos) {
                     // No space, use hard break. In this case, keep the broken character.
                     // -2 since we add a "-" separator for readability.
                     breakPos = descLength - 2;
                     hardBreak = true;
                     keepBrokenChar = true;
                 } else {
                     // We also want to keep the broken character in case it's not a whitespace.
                     if (explanation[breakPos] != ' ') {
                         breakPos++;
                         keepBrokenChar = true;
                     }
                 }
                 aMessageStream << std::setw(descLength) << std::left << explanation.substr(0, breakPos) + (hardBreak ? "-" : "");
                 explanation = explanation.substr(breakPos + (keepBrokenChar ? 0 : 1));
             } else {
                 aMessageStream << std::setw(descLength) << std::left << explanation;
                 // Trigger delayed break.
                 explanation.clear();
             }
             if (firstLine) {
                 aMessageStream << " default: ";
                 aOption.fWriteValue(aMessageStream);
                 firstLine = false;
             }
             aMessageStream << "\n";
         } while (explanation.length() > 0);
         if (std::count_if(aOption.lRequiredOptions.cbegin(), aOption.lRequiredOptions.cend(),
         [](const base * opt) {
         return ! opt->fIsHidden();
         })) {
             aMessageStream << "      " << std::setw(aMaxName) << " " << " Requires the following other options:\n";
             for (auto opt : aOption.lRequiredOptions) {
                 if (opt->fIsHidden()) {
                     continue;
                 }
                 aMessageStream << "      " << std::setw(aMaxName) << " " << "  " << opt->fGetLongName() << "\n";
             }
         }
         if (std::count_if(aOption.lForbiddenOptions.cbegin(), aOption.lForbiddenOptions.cend(),
         [](const base * opt) {
         return ! opt->fIsHidden();
         })) {
             aMessageStream << "      " << std::setw(aMaxName) << " " << " Forbids the following other options:\n";
             for (auto opt : aOption.lForbiddenOptions) {
                 if (opt->fIsHidden()) {
                     continue;
                 }
                 aMessageStream << "      " << std::setw(aMaxName) << " " << "  " << opt->fGetLongName() << "\n";
             }
         }
         if (lRequiredOptions.count(&aOption)) {
             aMessageStream << "      " << std::setw(aMaxName) << " " << "   this option is required\n";
         }
     }

References options::base::fGetLongName(), options::base::fIsHidden(), options::base::fWriteValue(), options::base::lExplanation, options::base::lForbiddenOptions, options::base::lLongName, options::base::lRequiredOptions, lRequiredOptions, and options::base::lShortName.

Referenced by fHelp().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fReadCfgFile()

void options::parser::fReadCfgFile	(	const std::string &	aFileName,
		const options::internal::sourceItem &	aSource,
		bool	aMayBeAbsent = `false`
	)

Definition at line 819 of file Options.cpp.

                                                                                                               {
         std::ifstream cfgFile(aFileName);
         if (!cfgFile.good() && !(aMayBeAbsent && errno == ENOENT)) {
             throw std::system_error(errno, std::system_category(),
                                     internal::conCat("can't acccess config file '", aFileName , "'."));
         }
         auto sourceF = new internal::sourceFile(aFileName, *(aSource.fGetFile()));
         int lineNumber = 0;
         std::vector<std::string>* preserveWorthyStuff = nullptr;
         bool hideNextOption = false;
         bool disableNextOption = false;
         try {
             while (cfgFile.good()) {
                 std::string line;
                 std::getline(cfgFile, line);
                 lineNumber++;
                 internal::sourceItem source(sourceF, lineNumber);
                 if (line.length() == 0) {
                     hideNextOption = false;
                     disableNextOption = false;
                     continue;
                 } else if (line[0] == '#') {
                     if (line[1] == '#') {
                         if (preserveWorthyStuff == nullptr) {
                             preserveWorthyStuff = new std::vector<std::string>;
                         }
                         preserveWorthyStuff->push_back(line);
                         if (line == "## hide") {
                             hideNextOption = true;
                         } else if (line == "## disable" && ! internal::gNoCfgFileRecursion) {
                             disableNextOption = true;
                         }
                     } else if (preserveWorthyStuff != nullptr) {
                         auto equalsAt = line.find_first_of('=');
                         if (equalsAt != std::string::npos) {
                             auto optionName = line.substr(2, equalsAt - 2);
                             auto it = base::fGetOptionMap().find(optionName);
                             if (it != base::fGetOptionMap().end()) {
                                 auto option = it->second;
                                 option->fSetPreserveWorthyStuff(preserveWorthyStuff);
                                 preserveWorthyStuff = nullptr;
                                 if (hideNextOption) {
                                     option->fHide();
                                 }
                                 if (disableNextOption) {
                                     option->fDisable();
                                 }
                             }
                         }
                     }
                     continue;
                 }
                 auto equalsAt = line.find_first_of('=');
                 if (equalsAt == std::string::npos || equalsAt < 1 || equalsAt == line.length()) {
                     std::string buf;
                     fReCaptureEscapedString(buf, line);
                     lUnusedOptions.push_back(buf);
                     continue;
                 }
                 auto optionName = line.substr(0, equalsAt);
                 auto it = base::fGetOptionMap().find(optionName);
                 if (it == base::fGetOptionMap().end()) {
                     throw std::runtime_error(internal::conCat("unknown option '", optionName, "'"));
                 }
                 auto option = it->second;
                 if (hideNextOption) {
                     option->fHide();
                 }
                 if (disableNextOption) {
                     option->fDisable();
                 }
                 {
                     std::stringstream sbuf(line.substr(equalsAt + 1));
                     option->fSetMe(sbuf, source);
                     if (preserveWorthyStuff != nullptr) {
                         option->fSetPreserveWorthyStuff(preserveWorthyStuff);
                         preserveWorthyStuff = nullptr;
                     }
                     option->fCheckRange();
                 }
             }
         } catch (const std::exception& e) {
             fGetErrorStream() << aFileName << ":" << lineNumber << ": error: " << e.what() << "\n";
             throw;
         }
  
         cfgFile.close();
     }

References options::internal::conCat(), fGetErrorStream(), options::internal::sourceItem::fGetFile(), options::base::fGetOptionMap(), fReCaptureEscapedString(), options::internal::gNoCfgFileRecursion, and lUnusedOptions.

Referenced by fReadConfigFiles(), and options::internal::OptionReadCfgFile< mayBeMissing >::fSetMe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fReadConfigFiles()

void options::parser::fReadConfigFiles ( )

protected

read config files if present

this function iterates over the list of config file search paths, replacing ~ by the home directory and then appends the program name to the path, and if a file is found it is then read as config file.

Definition at line 153 of file Options.cpp.

                                   {
         for (auto f : lSearchPaths) {
             auto tildePosition = f.find_first_of('~');
             if (tildePosition != std::string::npos) {
                 f.replace(tildePosition, 1, getenv("HOME"));
             }
             f += lProgName;
             fReadCfgFile(f, internal::sourceItem(), true);
         }
     }

References f(), fReadCfgFile(), lProgName, and lSearchPaths.

Referenced by fParse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fReCaptureEscapedString()

void options::parser::fReCaptureEscapedString	(	std::string &	aDest,
		const std::string &	aSource
	)

static

Definition at line 429 of file Options.cpp.

                                                                                    {
         std::stringstream buffer(aSource);
         buffer >> aDest;
     }

Referenced by fReadCfgFile().

Here is the caller graph for this function:

◆ fRequire() [1/2]

void options::parser::fRequire ( const base * aOtherOption )

virtual

Definition at line 135 of file Options.cpp.

                                              {
         lRequiredOptions.insert(aOption);
     }

References lRequiredOptions.

Referenced by main().

Here is the caller graph for this function:

◆ fRequire() [2/2]

void options::parser::fRequire ( std::vector< const base * > aOtherOptions )

virtual

Definition at line 138 of file Options.cpp.

                                                          {
         lRequiredOptions.insert(aOptions.cbegin(), aOptions.cend());
     }

References lRequiredOptions.

◆ fSetAssignmentChars()

void options::parser::fSetAssignmentChars	(	char	aPrimary = `'='`,
		char	aSecondary = `':'`
	)

Definition at line 127 of file Options.cpp.

                                                                    {
         lPrimaryAssignment = aPrimary;
         lSecondaryAssignment = aSecondary;
     }

References lPrimaryAssignment, and lSecondaryAssignment.

Referenced by parser().

Here is the caller graph for this function:

◆ fSetErrorStream()

void options::parser::fSetErrorStream ( std::ostream * aStream )

Definition at line 118 of file Options.cpp.

                                                     {
         lErrorStream = aStream;
     }

References lErrorStream.

◆ fSetExecutableName()

void options::parser::fSetExecutableName ( const char * aName )

Definition at line 131 of file Options.cpp.

                                                      {
         lExecutableName = aName;
     }

References lExecutableName.

Referenced by main().

Here is the caller graph for this function:

◆ fSetHelpReturnValue()

void options::parser::fSetHelpReturnValue ( int aValue )

Definition at line 124 of file Options.cpp.

                                                {
         lHelpReturnValue = aValue;
     }

References lHelpReturnValue.

Referenced by main().

Here is the caller graph for this function:

◆ fSetMessageStream()

void options::parser::fSetMessageStream ( std::ostream * aStream )

Definition at line 115 of file Options.cpp.

                                                       {
         lMessageStream = aStream;
     }

References lMessageStream.

Referenced by main().

Here is the caller graph for this function:

◆ fSetMinusMinusStartsExtraList()

void options::parser::fSetMinusMinusStartsExtraList ( )

switch on use of – to separate a trailer on the command line that is not to be parsed

Definition at line 372 of file Options.cpp.

                                                {
         lMinusMinusJustEndsOptions = false;
     }

References lMinusMinusJustEndsOptions.

Referenced by main().

Here is the caller graph for this function:

◆ fWriteCfgFile()

void options::parser::fWriteCfgFile ( const std::string & aFileName )

Definition at line 771 of file Options.cpp.

                                                          {
         std::ofstream cfgFile(aFileName, std::ofstream::out | std::ofstream::trunc);
         if (lExecutableName.empty()) {
             #ifdef IS_NONBROKEN_SYSTEM
             char buf[128];
             auto result = readlink("/proc/self/exe", buf, sizeof(buf));
             if (result > 0 && result < 128 - 2 - 14) {
                 cfgFile << "#!" << buf << " --readCfgFile\n";
             }
             #endif
         } else {
             cfgFile << "#!" << lExecutableName << " --readCfgFile\n";
         }
         {
             cfgFile << "# written ";
             std::time_t t = std::time(nullptr);
             char mbstr[100];
             if (std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%d %H:%M:%S", std::localtime(&t))) {
                 cfgFile << mbstr;
             }
             cfgFile << " by " << getenv("USER") << " using " << lProgName << "\n";
             cfgFile << "# only comments started by ## will be preserved on a re-write!\n";
             cfgFile << "# to rewrite this file for a different executable location, use:\n";
             cfgFile << "# " << lProgName << " --noCfgFileRecursion --readCfgFile " << aFileName << " --writeCfgFile " << aFileName << "\n";
             cfgFile << "# Assuming " << lProgName << " is in your PATH\n";
         }
         for (auto & it : base::fGetOptionMap()) {
             const auto opt = it.second;
             if (opt->lPreserveWorthyStuff != nullptr) {
                 for (const auto& line : * (opt->lPreserveWorthyStuff)) {
                     cfgFile << "\n" << line;
                 }
             }
             cfgFile << "\n# " << opt->lExplanation << "\n";
             auto prefix = "";
             if (opt->lSource.fIsUnset()) {
                 prefix = "# ";
             }
             opt->fWriteCfgLines(cfgFile, prefix);
             opt->fWriteRange(cfgFile);
             if (!opt->lSource.fIsUnset()) {
                 cfgFile << "# set from " << opt->lSource << "\n";
             }
         }
         cfgFile << "#\n";
         cfgFile.close();
     }

References options::base::fGetOptionMap(), lExecutableName, and lProgName.

Referenced by options::internal::OptionWriteCfgFile::fSetMe().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ gParser

parser * options::parser::gParser = nullptr

staticprotected

Definition at line 365 of file Options.h.

Referenced by fGetInstance(), parser(), and ~parser().

◆ lDescription

const std::string options::parser::lDescription

protected

Definition at line 366 of file Options.h.

Referenced by fHelp().

◆ lErrorStream

std::ostream* options::parser::lErrorStream

protected

Definition at line 376 of file Options.h.

Referenced by fGetErrorStream(), fSetErrorStream(), and parser().

◆ lExecutableName

std::string options::parser::lExecutableName

protected

Definition at line 378 of file Options.h.

Referenced by fSetExecutableName(), and fWriteCfgFile().

◆ lHelpReturnValue

int options::parser::lHelpReturnValue

protected

Definition at line 379 of file Options.h.

Referenced by fGetHelpReturnValue(), fSetHelpReturnValue(), and parser().

◆ lMessageStream

std::ostream* options::parser::lMessageStream

protected

Definition at line 375 of file Options.h.

Referenced by fHelp(), fSetMessageStream(), and parser().

◆ lMinusMinusJustEndsOptions

bool options::parser::lMinusMinusJustEndsOptions

protected

Definition at line 374 of file Options.h.

Referenced by fParse(), fSetMinusMinusStartsExtraList(), and parser().

◆ lParsingIsDone

bool options::parser::lParsingIsDone

protected

Definition at line 383 of file Options.h.

Referenced by fIsParsingDone(), and fParse().

◆ lPrimaryAssignment

char options::parser::lPrimaryAssignment

protected

Definition at line 380 of file Options.h.

Referenced by fParse(), and fSetAssignmentChars().

◆ lProgName

std::string options::parser::lProgName

protected

Definition at line 377 of file Options.h.

Referenced by fGetProgName(), fHelp(), fParse(), fReadConfigFiles(), and fWriteCfgFile().

◆ lRequiredOptions

std::set<const base*> options::parser::lRequiredOptions

protected

Definition at line 372 of file Options.h.

Referenced by fCheckConsistency(), fPrintOptionHelp(), and fRequire().

◆ lSearchPaths

const std::vector<std::string> options::parser::lSearchPaths

protected

Definition at line 368 of file Options.h.

Referenced by fHelp(), and fReadConfigFiles().

◆ lSecondaryAssignment

char options::parser::lSecondaryAssignment

protected

Definition at line 381 of file Options.h.

Referenced by fGetSecondaryAssignment(), and fSetAssignmentChars().

◆ lStuffAfterMinusMinus

std::vector<std::string> options::parser::lStuffAfterMinusMinus

protected

Definition at line 370 of file Options.h.

Referenced by fGetStuffAfterMinusMinus(), and fParse().

◆ lTrailer

const std::string options::parser::lTrailer

protected

Definition at line 367 of file Options.h.

Referenced by fHelp().

◆ lUnusedOptions

std::vector<std::string> options::parser::lUnusedOptions

protected

Definition at line 369 of file Options.h.

Referenced by fParse(), and fReadCfgFile().

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

OptionParser/src/include/Options.h (v0.19-24-g0617ca1 with changes)
OptionParser/src/Options.cpp (v0.19-24-g0617ca1 with changes)

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ parser()

◆ ~parser()

Member Function Documentation

◆ fCheckConsistency()

◆ fComplainAndLeave()

◆ fGetErrorStream()

◆ fGetHelpReturnValue()

◆ fGetInstance()

◆ fGetProgName()

◆ fGetSecondaryAssignment()

◆ fGetStuffAfterMinusMinus()

◆ fHelp()

◆ fIsParsingDone()

◆ fParse() [1/2]

◆ fParse() [2/2]

◆ fPrintEscapedString()

◆ fPrintOptionHelp()

◆ fReadCfgFile()

◆ fReadConfigFiles()

◆ fReCaptureEscapedString()

◆ fRequire() [1/2]

◆ fRequire() [2/2]

◆ fSetAssignmentChars()

◆ fSetErrorStream()

◆ fSetExecutableName()

◆ fSetHelpReturnValue()

◆ fSetMessageStream()

◆ fSetMinusMinusStartsExtraList()

◆ fWriteCfgFile()

Member Data Documentation

◆ gParser

◆ lDescription

◆ lErrorStream

◆ lExecutableName

◆ lHelpReturnValue

◆ lMessageStream

◆ lMinusMinusJustEndsOptions

◆ lParsingIsDone

◆ lPrimaryAssignment

◆ lProgName

◆ lRequiredOptions

◆ lSearchPaths

◆ lSecondaryAssignment

◆ lStuffAfterMinusMinus

◆ lTrailer

◆ lUnusedOptions