Command line parsing of argc and argv. More...

#include <command_args.h>

Classes
struct	CommandArgument

Public Member Functions
virtual	~CommandArgs ()

bool	parseArgs (int argc, char **argv, bool exitOnError=true)

void	param (const std::string &name, bool &p, bool defValue, const std::string &desc)

void	param (const std::string &name, int &p, int defValue, const std::string &desc)

void	param (const std::string &name, float &p, float defValue, const std::string &desc)

void	param (const std::string &name, double &p, double defValue, const std::string &desc)

void	param (const std::string &name, std::string &p, const std::string &defValue, const std::string &desc)

void	param (const std::string &name, std::vector< int > &p, const std::vector< int > &defValue, const std::string &desc)

void	param (const std::string &name, std::vector< double > &p, const std::vector< double > &defValue, const std::string &desc)

void	paramLeftOver (const std::string &name, std::string &p, const std::string &defValue, const std::string &desc, bool optional=false)

void	printParams (std::ostream &os)

const std::string &	getBanner () const
	return the banner string

void	setBanner (const std::string &banner)

void	printHelp (std::ostream &os)

bool	parsedParam (const std::string &paramFlag) const

Protected Member Functions
const char *	type2str (int t) const

void	str2arg (const std::string &input, CommandArgument &ca) const

std::string	arg2str (const CommandArgument &ca) const

Protected Attributes
std::vector< CommandArgument >	_args

std::vector< CommandArgument >	_leftOvers

std::vector< CommandArgument >	_leftOversOptional

std::string	_banner

std::string	_progName

Detailed Description

Command line parsing of argc and argv.

Parse the command line to get the program options. Additionally, we can store the config in a file and reload a parameter set from this file.

Definition at line 45 of file command_args.h.

Constructor & Destructor Documentation

◆ ~CommandArgs()

g2o::CommandArgs::~CommandArgs ( )

virtual

Definition at line 104 of file command_args.cpp.

104{}

Member Function Documentation

◆ arg2str()

std::string g2o::CommandArgs::arg2str ( const CommandArgument & ca ) const

protected

Definition at line 395 of file command_args.cpp.

                                                              {
  switch (ca.type) {
    case CAT_FLOAT:
      return argument2String<float>(ca);
    case CAT_DOUBLE:
      return argument2String<double>(ca);
    case CAT_INT:
      return argument2String<int>(ca);
    case CAT_BOOL:
      return argument2String<bool>(ca);
    case CAT_STRING: {
      string* data = static_cast<string*>(ca.data);
      return *data;
    }
    case CAT_VECTOR_INT: {
      std::vector<int>* data = static_cast<std::vector<int>*>(ca.data);
      return writeVectorAsString(*data);
    }
    case CAT_VECTOR_DOUBLE: {
      std::vector<double>* data = static_cast<std::vector<double>*>(ca.data);
      return writeVectorAsString(*data);
    }
  }
  return "";
}

References g2o::CAT_BOOL, g2o::CAT_DOUBLE, g2o::CAT_FLOAT, g2o::CAT_INT, g2o::CAT_STRING, g2o::CAT_VECTOR_DOUBLE, g2o::CAT_VECTOR_INT, g2o::CommandArgs::CommandArgument::data, and g2o::CommandArgs::CommandArgument::type.

Referenced by printHelp().

◆ getBanner()

const std::string & g2o::CommandArgs::getBanner ( ) const

inline

return the banner string

Definition at line 108 of file command_args.h.

108{ return _banner; }

g2o::CommandArgs::_banner

std::string _banner

Definition command_args.h:125

◆ param() [1/7]

void g2o::CommandArgs::param	(	const std::string &	name,
		bool &	p,
		bool	defValue,
		const std::string &	desc
	)

add a bool parameter, if found on the command line, will toggle defValue

Definition at line 188 of file command_args.cpp.

                                               {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_BOOL;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  p = defValue;
  _args.push_back(ca);
}

References _args, g2o::CAT_BOOL, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

Referenced by main(), parsedParam(), and g2o::RunG2OViewer::run().

◆ param() [2/7]

void g2o::CommandArgs::param	(	const std::string &	name,
		double &	p,
		double	defValue,
		const std::string &	desc
	)

add a float parameter

Definition at line 224 of file command_args.cpp.

                                               {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_DOUBLE;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  p = defValue;
  _args.push_back(ca);
}

References _args, g2o::CAT_DOUBLE, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

◆ param() [3/7]

void g2o::CommandArgs::param	(	const std::string &	name,
		float &	p,
		float	defValue,
		const std::string &	desc
	)

add a float parameter

Definition at line 212 of file command_args.cpp.

                                               {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_FLOAT;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  p = defValue;
  _args.push_back(ca);
}

References _args, g2o::CAT_FLOAT, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

◆ param() [4/7]

void g2o::CommandArgs::param	(	const std::string &	name,
		int &	p,
		int	defValue,
		const std::string &	desc
	)

add a int parameter

Definition at line 200 of file command_args.cpp.

                                               {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_INT;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  p = defValue;
  _args.push_back(ca);
}

References _args, g2o::CAT_INT, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

◆ param() [5/7]

void g2o::CommandArgs::param	(	const std::string &	name,
		std::string &	p,
		const std::string &	defValue,
		const std::string &	desc
	)

add a string parameter

Definition at line 236 of file command_args.cpp.

                                                                          {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_STRING;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  p = defValue;
  _args.push_back(ca);
}

References _args, g2o::CAT_STRING, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

◆ param() [6/7]

void g2o::CommandArgs::param	(	const std::string &	name,
		std::vector< double > &	p,
		const std::vector< double > &	defValue,
		const std::string &	desc
	)

add an vector of doubles as a parameter

Definition at line 261 of file command_args.cpp.

                                               {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_VECTOR_DOUBLE;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  p = defValue;
  _args.push_back(ca);
}

References _args, g2o::CAT_VECTOR_DOUBLE, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

◆ param() [7/7]

void g2o::CommandArgs::param	(	const std::string &	name,
		std::vector< int > &	p,
		const std::vector< int > &	defValue,
		const std::string &	desc
	)

add an int vector parameter

Definition at line 248 of file command_args.cpp.

                                               {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_VECTOR_INT;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  p = defValue;
  _args.push_back(ca);
}

References _args, g2o::CAT_VECTOR_INT, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

◆ paramLeftOver()

void g2o::CommandArgs::paramLeftOver	(	const std::string &	name,
		std::string &	p,
		const std::string &	defValue,
		const std::string &	desc,
		bool	optional = `false`
	)

add a param which is specified as a plain argument

Definition at line 331 of file command_args.cpp.

                                                                      {
  CommandArgument ca;
  ca.name = name;
  ca.description = desc;
  ca.type = CAT_STRING;
  ca.data = static_cast<void*>(&p);
  ca.parsed = false;
  ca.optional = optional;
  p = defValue;
  if (optional)
    _leftOversOptional.push_back(ca);
  else
    _leftOvers.push_back(ca);
}

References _leftOvers, _leftOversOptional, g2o::CAT_STRING, g2o::CommandArgs::CommandArgument::data, g2o::CommandArgs::CommandArgument::description, g2o::CommandArgs::CommandArgument::name, g2o::CommandArgs::CommandArgument::optional, g2o::CommandArgs::CommandArgument::parsed, and g2o::CommandArgs::CommandArgument::type.

Referenced by main(), and g2o::RunG2OViewer::run().

◆ parseArgs()

bool g2o::CommandArgs::parseArgs	(	int	argc,
		char **	argv,
		bool	exitOnError = `true`
	)

parse the command line for the requested parameters.

Parameters

argc	the number of params
argv	the value array
exitOnError	call exit() if the parsing fails

Returns: true, if parsing was correct

Definition at line 106 of file command_args.cpp.

                                                                   {
  _progName = argv[0];
  int i;
  for (i = 1; i < argc; i++) {
    string name = argv[i];
 
    if (name[0] != '-') {  // each param has to start with at least one dash
      // cerr << "Error: expecting parameter, got " << name << endl;
      // printHelp(cerr);
      // if (exitOnError)
      // exit(1);
      // return false;
      break;
    }
    /* first check whether it's -- and we should not continue parsing */
    if (name == "--") {
      ++i;
      break;
    }
 
    string::size_type dashPos = name.find_first_not_of('-');
    if (dashPos != string::npos) name = name.substr(dashPos);
 
    if (name == "help" || name == "h") {
      printHelp(cout);
      exit(0);
    } else {
      // command line argument parsing
      std::vector<CommandArgument>::iterator it = _args.begin();
      for (; it != _args.end(); ++it) {
        if (it->name == name) {
          if (it->type == CAT_BOOL) {
            if (!it->parsed) {
              bool* data = static_cast<bool*>(it->data);
              *data = !(*data);
            }
            it->parsed = true;
          } else {
            if (i >= argc - 1) {
              cerr << "Argument " << name << "needs value.\n";
              printHelp(cerr);
              if (exitOnError) exit(1);
              return false;
            }
            i++;
            str2arg(argv[i], *it);
            it->parsed = true;
          }
          break;
        }
      }
      if (it == _args.end()) {
        cerr << "Error: Unknown Option '" << name
             << "' (use -help to get list of options).\n";
        if (exitOnError) exit(1);
        return false;
      }
    }
  }  // for argv[i]
 
  if ((int)_leftOvers.size() > argc - i) {
    cerr << "Error: program requires parameters" << endl;
    printHelp(cerr);
    if (exitOnError) exit(1);
    return false;
  }
  for (size_t j = 0; (i < argc && j < _leftOvers.size()); i++, j++) {
    string* s = static_cast<string*>(_leftOvers[j].data);
    *s = argv[i];
    _leftOvers[j].parsed = true;
  }
 
  // the optional leftOvers
  for (size_t j = 0; (i < argc && j < _leftOversOptional.size()); i++, j++) {
    string* s = static_cast<string*>(_leftOversOptional[j].data);
    *s = argv[i];
    _leftOversOptional[j].parsed = true;
  }
 
  return true;
}

References _args, _leftOvers, _leftOversOptional, _progName, g2o::CAT_BOOL, printHelp(), and str2arg().

Referenced by main(), and g2o::RunG2OViewer::run().

◆ parsedParam()

bool g2o::CommandArgs::parsedParam ( const std::string & paramFlag ) const

returns true, if the param was parsed via the command line

Definition at line 421 of file command_args.cpp.

                                                          {
  std::vector<CommandArgument>::const_iterator it = _args.begin();
  for (; it != _args.end(); ++it) {
    if (it->name == param) {
      return it->parsed;
    }
  }
  return false;
}

References _args, and param().

Referenced by main().

◆ printHelp()

void g2o::CommandArgs::printHelp ( std::ostream & os )

print the help

Definition at line 274 of file command_args.cpp.

                                          {
  if (_banner.size()) os << _banner << endl;
  os << "Usage: " << _progName << (_args.size() > 0 ? " [options] " : " ");
  if (_leftOvers.size() > 0) {
    for (size_t i = 0; i < _leftOvers.size(); ++i) {
      if (i > 0) os << " ";
      os << _leftOvers[i].name;
    }
  }
  if (_leftOversOptional.size() > 0) {
    if (_leftOvers.size() > 0) os << " ";
    for (size_t i = 0; i < _leftOversOptional.size(); ++i) {
      if (i > 0) os << " ";
      os << "[" << _leftOversOptional[i].name << "]";
    }
  }
  os << endl << endl;
  os << "General options:" << endl;
  os << "-------------------------------------------" << endl;
  os << "-help / -h           Displays this help." << endl << endl;
  if (_args.size() > 0) {
    os << "Program Options:" << endl;
    os << "-------------------------------------------" << endl;
    // build up option string to print as table
    vector<pair<string, string> > tableStrings;
    tableStrings.reserve(_args.size());
    size_t maxArgLen = 0;
    for (size_t i = 0; i < _args.size(); ++i) {
      if (_args[i].type != CAT_BOOL) {
        string defaultValueStr = arg2str(_args[i]);
        if (!defaultValueStr.empty())
          tableStrings.push_back(make_pair(
              _args[i].name + " " + type2str(_args[i].type),
              _args[i].description + " (default: " + defaultValueStr + ")"));
        else
          tableStrings.push_back(
              make_pair(_args[i].name + " " + type2str(_args[i].type),
                        _args[i].description));
      } else
        tableStrings.push_back(make_pair(_args[i].name, _args[i].description));
      maxArgLen = (std::max)(maxArgLen, tableStrings.back().first.size());
    }
    sort(tableStrings.begin(), tableStrings.end(),
         CmpPairFirst<string, string>());
    maxArgLen += 3;
    for (size_t i = 0; i < tableStrings.size(); ++i) {
      os << "-" << tableStrings[i].first;
      for (size_t l = tableStrings[i].first.size(); l < maxArgLen; ++l)
        os << " ";
      os << tableStrings[i].second << endl;
    }
    // TODO should output description for leftOver params?
  }
}

References _args, _banner, _leftOvers, _leftOversOptional, _progName, arg2str(), g2o::CAT_BOOL, and type2str().

Referenced by parseArgs().

◆ printParams()

void g2o::CommandArgs::printParams ( std::ostream & os )

print the value of all params to an ostream

◆ setBanner()

void g2o::CommandArgs::setBanner ( const std::string & banner )

Definition at line 329 of file command_args.cpp.

329{ _banner = banner; }

References _banner.

◆ str2arg()

void g2o::CommandArgs::str2arg	(	const std::string &	input,
		CommandArgument &	ca
	)		const

protected

Definition at line 368 of file command_args.cpp.

                                                                           {
  switch (ca.type) {
    case CAT_FLOAT:
      parseArgument<float>(input, ca);
      break;
    case CAT_DOUBLE:
      parseArgument<double>(input, ca);
      break;
    case CAT_INT:
      parseArgument<int>(input, ca);
      break;
    case CAT_BOOL:
      parseArgument<bool>(input, ca);
      break;
    case CAT_STRING: {
      string* data = static_cast<string*>(ca.data);
      *data = input;
    } break;
    case CAT_VECTOR_INT: {
      parseVector<int>(input, ca);
    } break;
    case CAT_VECTOR_DOUBLE: {
      parseVector<double>(input, ca);
    } break;
  }
}

References g2o::CAT_BOOL, g2o::CAT_DOUBLE, g2o::CAT_FLOAT, g2o::CAT_INT, g2o::CAT_STRING, g2o::CAT_VECTOR_DOUBLE, g2o::CAT_VECTOR_INT, g2o::CommandArgs::CommandArgument::data, and g2o::CommandArgs::CommandArgument::type.

Referenced by parseArgs().

◆ type2str()

const char * g2o::CommandArgs::type2str ( int t ) const

protected

Definition at line 348 of file command_args.cpp.

                                             {
  switch (t) {
    case CAT_DOUBLE:
      return "<double>";
    case CAT_FLOAT:
      return "<float>";
    case CAT_INT:
      return "<int>";
    case CAT_STRING:
      return "<string>";
    case CAT_BOOL:
      return "<bool>";
    case CAT_VECTOR_INT:
      return "<vector_int>";
    case CAT_VECTOR_DOUBLE:
      return "<vector_double>";
  }
  return "";
}

References g2o::CAT_BOOL, g2o::CAT_DOUBLE, g2o::CAT_FLOAT, g2o::CAT_INT, g2o::CAT_STRING, g2o::CAT_VECTOR_DOUBLE, and g2o::CAT_VECTOR_INT.

Referenced by printHelp().

Member Data Documentation

◆ _args

std::vector<CommandArgument> g2o::CommandArgs::_args

protected

Definition at line 122 of file command_args.h.

Referenced by param(), param(), param(), param(), param(), param(), param(), parseArgs(), parsedParam(), and printHelp().

◆ _banner

std::string g2o::CommandArgs::_banner

protected

Definition at line 125 of file command_args.h.

Referenced by printHelp(), and setBanner().

◆ _leftOvers

std::vector<CommandArgument> g2o::CommandArgs::_leftOvers

protected

Definition at line 123 of file command_args.h.

Referenced by paramLeftOver(), parseArgs(), and printHelp().

◆ _leftOversOptional

std::vector<CommandArgument> g2o::CommandArgs::_leftOversOptional

protected

Definition at line 124 of file command_args.h.

Referenced by paramLeftOver(), parseArgs(), and printHelp().

◆ _progName

std::string g2o::CommandArgs::_progName

protected

Definition at line 126 of file command_args.h.

Referenced by parseArgs(), and printHelp().

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

/build/reproducible-path/g2o-0~20230806/g2o/stuff/command_args.h
/build/reproducible-path/g2o-0~20230806/g2o/stuff/command_args.cpp

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~CommandArgs()

Member Function Documentation

◆ arg2str()

◆ getBanner()

◆ param() [1/7]

◆ param() [2/7]

◆ param() [3/7]

◆ param() [4/7]

◆ param() [5/7]

◆ param() [6/7]

◆ param() [7/7]

◆ paramLeftOver()

◆ parseArgs()

◆ parsedParam()

◆ printHelp()

◆ printParams()

◆ setBanner()

◆ str2arg()

◆ type2str()

Member Data Documentation

◆ _args

◆ _banner

◆ _leftOvers

◆ _leftOversOptional

◆ _progName