g2o::CommandArgs Class Reference

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

#include <command_args.h>

Classes
struct	CommandArgument

Public Member Functions
	CommandArgs ()
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 More...
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
std::string	trim (const std::string &s) 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 46 of file command_args.h.

Constructor & Destructor Documentation

g2o::CommandArgs::CommandArgs

(

)

Definition at line 103 of file command_args.cpp.

{
}

g2o::CommandArgs::~CommandArgs ( )

virtual

Definition at line 107 of file command_args.cpp.

{
}

Member Function Documentation

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

protected

Definition at line 451 of file command_args.cpp.

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

{
  switch (ca.type) {
    case CAT_FLOAT:
      {
        float* data = static_cast<float*>(ca.data);
        stringstream auxStream;
        auxStream << *data;
        return auxStream.str();
      }
    case CAT_DOUBLE:
      {
        double* data = static_cast<double*>(ca.data);
        stringstream auxStream;
        auxStream << *data;
        return auxStream.str();
      }
    case CAT_INT:
      {
        int* data = static_cast<int*>(ca.data);
        stringstream auxStream;
        auxStream << *data;
        return auxStream.str();
      }
    case CAT_BOOL:
      {
        bool* data = static_cast<bool*>(ca.data);
        stringstream auxStream;
        auxStream << *data;
        return auxStream.str();
      }
    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);
        stringstream auxStream;
        auxStream << (*data);
        return auxStream.str();
      }
    case CAT_VECTOR_DOUBLE:
      {
        std::vector<double> * data = static_cast< std::vector<double> * >(ca.data);
        stringstream auxStream;
        auxStream << (*data);
        return auxStream.str();
      }
  }
  return "";
}

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

inline

return the banner string

Definition at line 96 of file command_args.h.

{ return _banner; }

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 198 of file command_args.cpp.

References 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().

{
  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);
}

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

add a int parameter

Definition at line 210 of file command_args.cpp.

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

{
  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);
}

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

add a float parameter

Definition at line 222 of file command_args.cpp.

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

{
  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);
}

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

add a float parameter

Definition at line 234 of file command_args.cpp.

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

{
  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);
}

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 246 of file command_args.cpp.

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

{
  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);
}

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 258 of file command_args.cpp.

References 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.

                                                                                                                      {
  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);
}

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 269 of file command_args.cpp.

References 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.

{
  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);
}

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 wich is specified as a plain argument

Definition at line 342 of file command_args.cpp.

References 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().

{
  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);
}

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 111 of file command_args.cpp.

References g2o::CAT_BOOL.

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

{
  _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];
  }

  // 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];
  }

  return true;
}

bool g2o::CommandArgs::parsedParam

(

const std::string &

paramFlag

)

const

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

Definition at line 548 of file command_args.cpp.

Referenced by main().

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

void g2o::CommandArgs::printHelp

(

std::ostream &

os

)

print the help

Definition at line 281 of file command_args.cpp.

References g2o::CAT_BOOL.

{
  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?
  }
}

void g2o::CommandArgs::printParams

(

std::ostream &

os

)

print the value of all params to an ostream

void g2o::CommandArgs::setBanner

(

const std::string &

banner

)

Definition at line 337 of file command_args.cpp.

{
  _banner = banner;
}

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

protected

Definition at line 379 of file command_args.cpp.

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

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

std::string g2o::CommandArgs::trim ( const std::string &  s ) const

protected

Definition at line 505 of file command_args.cpp.

{
  if(s.length() == 0)
    return s;
  string::size_type b = s.find_first_not_of(" \t\n");
  string::size_type e = s.find_last_not_of(" \t\n");
  if(b == string::npos)
    return "";
  return std::string(s, b, e - b + 1);
}

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

protected

Definition at line 358 of file command_args.cpp.

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

{
  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 "";
}

Member Data Documentation

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

protected

Definition at line 110 of file command_args.h.

std::string g2o::CommandArgs::_banner

protected

Definition at line 113 of file command_args.h.

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

protected

Definition at line 111 of file command_args.h.

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

protected

Definition at line 112 of file command_args.h.

std::string g2o::CommandArgs::_progName

protected

Definition at line 114 of file command_args.h.

---

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

• /home/xuezhisd/CLionProjects/g2o/g2o/stuff/command_args.h
• /home/xuezhisd/CLionProjects/g2o/g2o/stuff/command_args.cpp