ParseOptions Class Reference

The class ParseOptions is for parsing command-line options; see Parsing command-line options for more documentation. More...

#include <parse-options.h>

Inheritance diagram for ParseOptions:

Collaboration diagram for ParseOptions:

Classes
struct	DocInfo
	Structure for options' documentation. More...

Public Member Functions
	ParseOptions (const char *usage)
	ParseOptions (const std::string &prefix, OptionsItf *other)
	This is a constructor for the special case where some options are registered with a prefix to avoid conflicts. More...
	~ParseOptions ()
void	Register (const std::string &name, bool *ptr, const std::string &doc)
void	Register (const std::string &name, int32 *ptr, const std::string &doc)
void	Register (const std::string &name, uint32 *ptr, const std::string &doc)
void	Register (const std::string &name, float *ptr, const std::string &doc)
void	Register (const std::string &name, double *ptr, const std::string &doc)
void	Register (const std::string &name, std::string *ptr, const std::string &doc)
void	DisableOption (const std::string &name)
	If called after registering an option and before calling Read(), disables that option from being used. More...
template<typename T >
void	RegisterStandard (const std::string &name, T *ptr, const std::string &doc)
	This one is used for registering standard parameters of all the programs. More...
int	Read (int argc, const char *const *argv)
	Parses the command line options and fills the ParseOptions-registered variables. More...
void	PrintUsage (bool print_command_line=false)
	Prints the usage documentation [provided in the constructor]. More...
void	PrintConfig (std::ostream &os)
	Prints the actual configuration of all the registered variables. More...
void	ReadConfigFile (const std::string &filename)
	Reads the options values from a config file. More...
int	NumArgs () const
	Number of positional parameters (c.f. argc-1). More...
std::string	GetArg (int param) const
	Returns one of the positional parameters; 1-based indexing for argc/argv compatibility. More...
std::string	GetOptArg (int param) const
Public Member Functions inherited from OptionsItf
virtual	~OptionsItf ()

Static Public Member Functions
static std::string	Escape (const std::string &str)
	The following function will return a possibly quoted and escaped version of "str", according to the current shell. More...

Protected Member Functions
void	SplitLongArg (const std::string &in, std::string *key, std::string *value, bool *has_equal_sign)
	SplitLongArg parses an argument of the form –a=b, –a=, or –a,. More...
void	NormalizeArgName (std::string *str)

Private Types
typedef std::map< std::string, DocInfo >	DocMapType

Private Member Functions
template<typename T >
void	RegisterTmpl (const std::string &name, T *ptr, const std::string &doc)
	Template to register various variable types, used for program-specific parameters. More...
void	RegisterSpecific (const std::string &name, const std::string &idx, bool *b, const std::string &doc, bool is_standard)
	Register boolean variable. More...
void	RegisterSpecific (const std::string &name, const std::string &idx, int32 *i, const std::string &doc, bool is_standard)
	Register int32 variable. More...
void	RegisterSpecific (const std::string &name, const std::string &idx, uint32 *u, const std::string &doc, bool is_standard)
	Register unsinged int32 variable. More...
void	RegisterSpecific (const std::string &name, const std::string &idx, float *f, const std::string &doc, bool is_standard)
	Register float variable. More...
void	RegisterSpecific (const std::string &name, const std::string &idx, double *f, const std::string &doc, bool is_standard)
	Register double variable [useful as we change BaseFloat type]. More...
void	RegisterSpecific (const std::string &name, const std::string &idx, std::string *s, const std::string &doc, bool is_standard)
	Register string variable. More...
template<typename T >
void	RegisterCommon (const std::string &name, T *ptr, const std::string &doc, bool is_standard)
	Does the actual job for both kinds of parameters Does the common part of the job for all datatypes, then calls RegisterSpecific. More...
bool	SetOption (const std::string &key, const std::string &value, bool has_equal_sign)
	Set option with name "key" to "value"; will crash if can't do it. More...
bool	ToBool (std::string str)
int32	ToInt (const std::string &str)
uint32	ToUint (const std::string &str)
float	ToFloat (const std::string &str)
double	ToDouble (const std::string &str)

Private Attributes
std::map< std::string, bool * >	bool_map_
std::map< std::string, int32 * >	int_map_
std::map< std::string, uint32 * >	uint_map_
std::map< std::string, float * >	float_map_
std::map< std::string, double * >	double_map_
std::map< std::string, std::string * >	string_map_
DocMapType	doc_map_
	map for the documentation More...
bool	print_args_
	variable for the implicit –print-args parameter More...
bool	help_
	variable for the implicit –help parameter More...
std::string	config_
	variable for the implicit –config parameter More...
std::vector< std::string >	positional_args_
const char *	usage_
int	argc_
const char *const *	argv_
std::string	prefix_
	These members are not normally used. More...
OptionsItf *	other_parser_

Detailed Description

The class ParseOptions is for parsing command-line options; see Parsing command-line options for more documentation.

Definition at line 36 of file parse-options.h.

Member Typedef Documentation

DocMapType

typedef std::map<std::string, DocInfo> DocMapType

private

Definition at line 206 of file parse-options.h.

Constructor & Destructor Documentation

ParseOptions() [1/2]

ParseOptions ( const char *  usage )

inlineexplicit

Definition at line 38 of file parse-options.h.

References ParseOptions::config_, kaldi::g_kaldi_verbose_level, ParseOptions::help_, ParseOptions::print_args_, and ParseOptions::RegisterStandard().

                                           :
    print_args_(true), help_(false), usage_(usage), argc_(0), argv_(NULL),
    prefix_(""), other_parser_(NULL) {
#if !defined(_MSC_VER) && !defined(__CYGWIN__) // This is just a convenient place to set the stderr to line
    setlinebuf(stderr);  // buffering mode, since it's called at program start.
#endif  // This helps ensure different programs' output is not mixed up.
    RegisterStandard("config", &config_, "Configuration file to read (this "
                     "option may be repeated)");
    RegisterStandard("print-args", &print_args_,
                     "Print the command line arguments (to stderr)");
    RegisterStandard("help", &help_, "Print out usage message");
    RegisterStandard("verbose", &g_kaldi_verbose_level,
                     "Verbose level (higher->more logging)");
  }

ParseOptions() [2/2]

ParseOptions	(	const std::string &	prefix,
		OptionsItf *	other
	)

This is a constructor for the special case where some options are registered with a prefix to avoid conflicts.

The object thus created will only be used temporarily to register an options class with the original options parser (which is passed as the *other pointer) using the given prefix. It should not be used for any other purpose, and the prefix must not be the empty string. It seems to be the least bad way of implementing options with prefixes at this point. Example of usage is: ParseOptions po; // original ParseOptions object ParseOptions po_mfcc("mfcc", &po); // object with prefix. MfccOptions mfcc_opts; mfcc_opts.Register(&po_mfcc); The options will now get registered as, e.g., –mfcc.frame-shift=10.0 instead of just –frame-shift=10.0

Definition at line 39 of file parse-options.cc.

References ParseOptions::other_parser_, and ParseOptions::prefix_.

                                             :
    print_args_(false), help_(false), usage_(""), argc_(0), argv_(NULL) {
  ParseOptions *po = dynamic_cast<ParseOptions*>(other);
  if (po != NULL && po->other_parser_ != NULL) {
    // we get here if this constructor is used twice, recursively.
    other_parser_ = po->other_parser_;
  } else {
    other_parser_ = other;
  }
  if (po != NULL && po->prefix_ != "") {
    prefix_ = po->prefix_ + std::string(".") + prefix;
  } else {
    prefix_ = prefix;
  }
}

~ParseOptions()

~ParseOptions ( )

inline

Definition at line 71 of file parse-options.h.

References ParseOptions::DisableOption(), ParseOptions::GetArg(), ParseOptions::NumArgs(), ParseOptions::PrintConfig(), ParseOptions::PrintUsage(), ParseOptions::Read(), ParseOptions::ReadConfigFile(), ParseOptions::Register(), and ParseOptions::RegisterStandard().

{}

Member Function Documentation

DisableOption()

void DisableOption

(

const std::string &

name

)

If called after registering an option and before calling Read(), disables that option from being used.

Will crash at runtime if that option had not been registered.

Definition at line 183 of file parse-options.cc.

References ParseOptions::argv_, ParseOptions::bool_map_, ParseOptions::doc_map_, ParseOptions::double_map_, ParseOptions::float_map_, ParseOptions::int_map_, KALDI_ERR, ParseOptions::string_map_, and ParseOptions::uint_map_.

Referenced by ParseOptions::~ParseOptions().

                                                      {
  if (argv_ != NULL)
    KALDI_ERR << "DisableOption must not be called after calling Read().";
  if (doc_map_.erase(name) == 0)
    KALDI_ERR << "Option " << name
              << " was not registered so cannot be disabled: ";
  bool_map_.erase(name);
  int_map_.erase(name);
  uint_map_.erase(name);
  float_map_.erase(name);
  double_map_.erase(name);
  string_map_.erase(name);
}

Escape()

std::string Escape ( const std::string &  str )

static

The following function will return a possibly quoted and escaped version of "str", according to the current shell.

Currently this is just hardwired to bash. It's useful for debug output.

Definition at line 306 of file parse-options.cc.

References kaldi::MustBeQuoted(), and kaldi::QuoteAndEscape().

Referenced by ParseOptions::GetOptArg(), kaldi::PrintableRxfilename(), kaldi::PrintableWxfilename(), ParseOptions::PrintUsage(), and ParseOptions::Read().

                                                   {
  return MustBeQuoted(str, kShellType) ? QuoteAndEscape(str, kShellType) : str;
}

GetArg()

std::string GetArg

(

int

param

)

const

Returns one of the positional parameters; 1-based indexing for argc/argv compatibility.

Will crash if param is not >=1 and <=NumArgs().

Definition at line 202 of file parse-options.cc.

References rnnlm::i, KALDI_ERR, and ParseOptions::positional_args_.

Referenced by ComputeLogPosteriors(), ComputeScores(), ParseOptions::GetOptArg(), main(), kaldi::TypeOneUsage(), kaldi::TypeOneUsageAverage(), kaldi::TypeThreeUsage(), kaldi::TypeTwoUsage(), kaldi::UnitTestParseOptions(), and ParseOptions::~ParseOptions().

                                          {
  // use KALDI_ERR if code error
  if (i < 1 || i > static_cast<int>(positional_args_.size()))
    KALDI_ERR << "ParseOptions::GetArg, invalid index " << i;
  return positional_args_[i - 1];
}

GetOptArg()

std::string GetOptArg ( int  param ) const

inline

Definition at line 127 of file parse-options.h.

References ParseOptions::Escape(), ParseOptions::GetArg(), rnnlm::i, ParseOptions::NumArgs(), ParseOptions::RegisterCommon(), ParseOptions::RegisterSpecific(), ParseOptions::RegisterTmpl(), ParseOptions::SetOption(), ParseOptions::ToBool(), ParseOptions::ToDouble(), ParseOptions::ToFloat(), ParseOptions::ToInt(), and ParseOptions::ToUint().

Referenced by main().

                                       {
    return (param <= NumArgs() ? GetArg(param) : "");
  }

NormalizeArgName()

void NormalizeArgName ( std::string *  str )

protected

Definition at line 522 of file parse-options.cc.

References KALDI_ASSERT.

Referenced by ParseOptions::Read(), ParseOptions::ReadConfigFile(), and ParseOptions::RegisterCommon().

                                                  {
  std::string out;
  std::string::iterator it;

  for (it = str->begin(); it != str->end(); ++it) {
    if (*it == '_')
      out += '-';  // convert _ to -
    else
      out += std::tolower(*it);
  }
  *str = out;

  KALDI_ASSERT(str->length() > 0);
}

NumArgs()

int NumArgs

(

)

const

Number of positional parameters (c.f. argc-1).

Definition at line 198 of file parse-options.cc.

References ParseOptions::positional_args_.

Referenced by ParseOptions::GetOptArg(), main(), kaldi::TypeOneUsage(), kaldi::TypeOneUsageAverage(), kaldi::TypeThreeUsage(), kaldi::TypeTwoUsage(), kaldi::UnitTestParseOptions(), and ParseOptions::~ParseOptions().

                                {
  return positional_args_.size();
}

PrintConfig()

void PrintConfig

(

std::ostream &

os

)

Prints the actual configuration of all the registered variables.

Definition at line 431 of file parse-options.cc.

References ParseOptions::bool_map_, ParseOptions::doc_map_, ParseOptions::double_map_, ParseOptions::float_map_, ParseOptions::int_map_, KALDI_ERR, ParseOptions::string_map_, and ParseOptions::uint_map_.

Referenced by ParseOptions::~ParseOptions().

                                             {
  os << '\n' << "[[ Configuration of UI-Registered options ]]" << '\n';
  std::string key;
  DocMapType::iterator it;
  for (it = doc_map_.begin(); it != doc_map_.end(); ++it) {
    key = it->first;
    os << it->second.name_ << " = ";
    if (bool_map_.end() != bool_map_.find(key)) {
      os << (*bool_map_[key] ? "true" : "false");
    } else if (int_map_.end() != int_map_.find(key)) {
      os << (*int_map_[key]);
    } else if (uint_map_.end() != uint_map_.find(key)) {
      os << (*uint_map_[key]);
    } else if (float_map_.end() != float_map_.find(key)) {
      os << (*float_map_[key]);
    } else if (double_map_.end() != double_map_.find(key)) {
      os << (*double_map_[key]);
    } else if (string_map_.end() != string_map_.find(key)) {
      os << "'" << *string_map_[key] << "'";
    } else {
      KALDI_ERR << "PrintConfig: unrecognized option " << key << "[code error]";
    }
    os << '\n';
  }
  os << '\n';
}

PrintUsage()

void PrintUsage

(

bool

print_command_line = false

)

Prints the usage documentation [provided in the constructor].

Definition at line 393 of file parse-options.cc.

References ParseOptions::argc_, ParseOptions::argv_, ParseOptions::doc_map_, ParseOptions::Escape(), rnnlm::j, and ParseOptions::usage_.

Referenced by main(), ParseOptions::Read(), ParseOptions::ReadConfigFile(), ParseOptions::SplitLongArg(), ParseOptions::ToBool(), kaldi::UnitTestParseOptions(), and ParseOptions::~ParseOptions().

                                                     {
  std::cerr << '\n' << usage_ << '\n';
  DocMapType::iterator it;
  // first we print application-specific options
  bool app_specific_header_printed = false;
  for (it = doc_map_.begin(); it != doc_map_.end(); ++it) {
    if (it->second.is_standard_ == false) {  // application-specific option
      if (app_specific_header_printed == false) {  // header was not yet printed
        std::cerr << "Options:" << '\n';
        app_specific_header_printed = true;
      }
      std::cerr << "  --" << std::setw(25) << std::left << it->second.name_
          << " : " << it->second.use_msg_ << '\n';
    }
  }
  if (app_specific_header_printed == true) {
    std::cerr << '\n';
  }

  // then the standard options
  std::cerr << "Standard options:" << '\n';
  for (it = doc_map_.begin(); it != doc_map_.end(); ++it) {
    if (it->second.is_standard_ == true) {  // we have standard option
      std::cerr << "  --" << std::setw(25) << std::left << it->second.name_
          << " : " << it->second.use_msg_ << '\n';
    }
  }
  std::cerr << '\n';
  if (print_command_line) {
    std::ostringstream strm;
    strm << "Command line was: ";
    for (int j = 0; j < argc_; j++)
      strm << Escape(argv_[j]) << " ";
    strm << '\n';
    std::cerr << strm.str() << std::flush;
  }
}

Read()

int Read	(	int	argc,
		const char *const *	argv
	)

Parses the command line options and fills the ParseOptions-registered variables.

This must be called after all the variables were registered!!!

Initially the variables have implicit values, then the config file values are set-up, finally the command line values given. Returns the first position in argv that was not used. [typically not useful: use NumParams() and GetParam(). ]

Definition at line 311 of file parse-options.cc.

References ParseOptions::argc_, ParseOptions::argv_, ParseOptions::Escape(), rnnlm::i, rnnlm::j, KALDI_ERR, ParseOptions::NormalizeArgName(), ParseOptions::positional_args_, ParseOptions::print_args_, ParseOptions::PrintUsage(), ParseOptions::ReadConfigFile(), ParseOptions::SetOption(), kaldi::SetProgramName(), ParseOptions::SplitLongArg(), and kaldi::Trim().

Referenced by main(), kaldi::UnitTestParseOptions(), and ParseOptions::~ParseOptions().

                                                         {
  argc_ = argc;
  argv_ = argv;
  std::string key, value;
  int i;
  if (argc > 0) {
    // set global "const char*" g_program_name (name of the program)
    // so it can be printed out in error messages;
    // it's useful because often the stderr of different programs will
    // be mixed together in the same log file.
#ifdef _MSC_VER
    const char *c = strrchr(argv[0], '\\');
#else
    const char *c = strrchr(argv[0], '/');
#endif
    SetProgramName(c == NULL ? argv[0] : c + 1);
  }
  // first pass: look for config parameter, look for priority
  for (i = 1; i < argc; i++) {
    if (std::strncmp(argv[i], "--", 2) == 0) {
      if (std::strcmp(argv[i], "--") == 0) {
        // a lone "--" marks the end of named options
        break;
      }
      bool has_equal_sign;
      SplitLongArg(argv[i], &key, &value, &has_equal_sign);
      NormalizeArgName(&key);
      Trim(&value);
      if (key.compare("config") == 0) {
        ReadConfigFile(value);
      }
      if (key.compare("help") == 0) {
        PrintUsage();
        exit(0);
      }
    }
  }
  bool double_dash_seen = false;
  // second pass: add the command line options
  for (i = 1; i < argc; i++) {
    if (std::strncmp(argv[i], "--", 2) == 0) {
      if (std::strcmp(argv[i], "--") == 0) {
        // A lone "--" marks the end of named options.
        // Skip that option and break the processing of named options
        i += 1;
        double_dash_seen = true;
        break;
      }
      bool has_equal_sign;
      SplitLongArg(argv[i], &key, &value, &has_equal_sign);
      NormalizeArgName(&key);
      Trim(&value);
      if (!SetOption(key, value, has_equal_sign)) {
        PrintUsage(true);
        KALDI_ERR << "Invalid option " << argv[i];
      }
    } else {
      break;
    }
  }

  // process remaining arguments as positional
  for (; i < argc; i++) {
    if ((std::strcmp(argv[i], "--") == 0) && !double_dash_seen) {
      double_dash_seen = true;
    } else {
      positional_args_.push_back(std::string(argv[i]));
    }
  }

  // if the user did not suppress this with --print-args = false....
  if (print_args_) {
    std::ostringstream strm;
    for (int j = 0; j < argc; j++)
      strm << Escape(argv[j]) << " ";
    strm << '\n';
    std::cerr << strm.str() << std::flush;
  }
  return i;
}

ReadConfigFile()

void ReadConfigFile

(

const std::string &

filename

)

Reads the options values from a config file.

Must be called after registering all options. This is usually used internally after the standard –config option is used, but it may also be called from a program.

Definition at line 459 of file parse-options.cc.

References KALDI_ERR, line_number, ParseOptions::NormalizeArgName(), ParseOptions::PrintUsage(), ParseOptions::SetOption(), ParseOptions::SplitLongArg(), and kaldi::Trim().

Referenced by ParseOptions::Read(), and ParseOptions::~ParseOptions().

                                                           {
  std::ifstream is(filename.c_str(), std::ifstream::in);
  if (!is.good()) {
    KALDI_ERR << "Cannot open config file: " << filename;
  }

  std::string line, key, value;
  int32 line_number = 0;
  while (std::getline(is, line)) {
    line_number++;
    // trim out the comments
    size_t pos;
    if ((pos = line.find_first_of('#')) != std::string::npos) {
      line.erase(pos);
    }
    // skip empty lines
    Trim(&line);
    if (line.length() == 0) continue;

    if (line.substr(0, 2) != "--") {
      KALDI_ERR << "Reading config file " << filename
                << ": line " << line_number << " does not look like a line "
                << "from a Kaldi command-line program's config file: should "
                << "be of the form --x=y.  Note: config files intended to "
                << "be sourced by shell scripts lack the '--'.";
    }

    // parse option
    bool has_equal_sign;
    SplitLongArg(line, &key, &value, &has_equal_sign);
    NormalizeArgName(&key);
    Trim(&value);
    if (!SetOption(key, value, has_equal_sign)) {
      PrintUsage(true);
      KALDI_ERR << "Invalid option " << line << " in config file " << filename;
    }
  }
}

Register() [1/6]

void Register ( const std::string &  name, bool *  ptr, const std::string &  doc  )

virtual

Implements OptionsItf.

Definition at line 56 of file parse-options.cc.

References ParseOptions::RegisterTmpl().

Referenced by main(), kaldi::ReadConfigFromFile(), kaldi::ReadConfigsFromFile(), DummyOptions::Register(), ImageAugmentationConfig::Register(), OnlineCmvnOptions::Register(), ProcessPitchOptions::Register(), OnlineSpliceOptions::Register(), kaldi::UnitTestParseOptions(), and ParseOptions::~ParseOptions().

                                                             {
  RegisterTmpl(name, ptr, doc);
}

Register() [2/6]

void Register ( const std::string &  name, int32 *  ptr, const std::string &  doc  )

virtual

Implements OptionsItf.

Definition at line 61 of file parse-options.cc.

References ParseOptions::RegisterTmpl().

                                                              {
  RegisterTmpl(name, ptr, doc);
}

Register() [3/6]

void Register ( const std::string &  name, uint32 *  ptr, const std::string &  doc  )

virtual

Implements OptionsItf.

Definition at line 66 of file parse-options.cc.

References ParseOptions::RegisterTmpl().

                                                               {
  RegisterTmpl(name, ptr, doc);
}

Register() [4/6]

void Register ( const std::string &  name, float *  ptr, const std::string &  doc  )

virtual

Implements OptionsItf.

Definition at line 71 of file parse-options.cc.

References ParseOptions::RegisterTmpl().

                                                              {
  RegisterTmpl(name, ptr, doc);
}

Register() [5/6]

void Register ( const std::string &  name, double *  ptr, const std::string &  doc  )

virtual

Implements OptionsItf.

Definition at line 76 of file parse-options.cc.

References ParseOptions::RegisterTmpl().

                                                               {
  RegisterTmpl(name, ptr, doc);
}

Register() [6/6]

void Register ( const std::string &  name, std::string *  ptr, const std::string &  doc  )

virtual

Implements OptionsItf.

Definition at line 81 of file parse-options.cc.

References ParseOptions::RegisterTmpl().

                                                                  {
  RegisterTmpl(name, ptr, doc);
}

RegisterCommon()

template void RegisterCommon ( const std::string &  name, T *  ptr, const std::string &  doc, bool  is_standard  )

private

Does the actual job for both kinds of parameters Does the common part of the job for all datatypes, then calls RegisterSpecific.

Definition at line 102 of file parse-options.cc.

References ParseOptions::doc_map_, KALDI_ASSERT, KALDI_WARN, ParseOptions::NormalizeArgName(), and ParseOptions::RegisterSpecific().

Referenced by ParseOptions::GetOptArg(), ParseOptions::RegisterStandard(), ParseOptions::RegisterTmpl(), and ParseOptions::ToDouble().

                                                                          {
  KALDI_ASSERT(ptr != NULL);
  std::string idx = name;
  NormalizeArgName(&idx);
  if (doc_map_.find(idx) != doc_map_.end())
    KALDI_WARN << "Registering option twice, ignoring second time: " << name;
  this->RegisterSpecific(name, idx, ptr, doc, is_standard);
}

RegisterSpecific() [1/6]

void RegisterSpecific ( const std::string &  name, const std::string &  idx, bool *  b, const std::string &  doc, bool  is_standard  )

private

Register boolean variable.

Definition at line 120 of file parse-options.cc.

References ParseOptions::bool_map_, and ParseOptions::doc_map_.

Referenced by ParseOptions::GetOptArg(), and ParseOptions::RegisterCommon().

                                                      {
  bool_map_[idx] = b;
  doc_map_[idx] = DocInfo(name, doc + " (bool, default = "
                          + ((*b)? "true)" : "false)"), is_standard);
}

RegisterSpecific() [2/6]

void RegisterSpecific ( const std::string &  name, const std::string &  idx, int32 *  i, const std::string &  doc, bool  is_standard  )

private

Register int32 variable.

Definition at line 130 of file parse-options.cc.

References ParseOptions::doc_map_, rnnlm::i, and ParseOptions::int_map_.

                                                      {
  int_map_[idx] = i;
  std::ostringstream ss;
  ss << doc << " (int, default = " << *i << ")";
  doc_map_[idx] = DocInfo(name, ss.str(), is_standard);
}

RegisterSpecific() [3/6]

void RegisterSpecific ( const std::string &  name, const std::string &  idx, uint32 *  u, const std::string &  doc, bool  is_standard  )

private

Register unsinged int32 variable.

Definition at line 141 of file parse-options.cc.

References ParseOptions::doc_map_, and ParseOptions::uint_map_.

                                                      {
  uint_map_[idx] = u;
  std::ostringstream ss;
  ss << doc << " (uint, default = " << *u << ")";
  doc_map_[idx] = DocInfo(name, ss.str(), is_standard);
}

RegisterSpecific() [4/6]

void RegisterSpecific ( const std::string &  name, const std::string &  idx, float *  f, const std::string &  doc, bool  is_standard  )

private

Register float variable.

Definition at line 152 of file parse-options.cc.

References ParseOptions::doc_map_, and ParseOptions::float_map_.

                                                      {
  float_map_[idx] = f;
  std::ostringstream ss;
  ss << doc << " (float, default = " << *f << ")";
  doc_map_[idx] = DocInfo(name, ss.str(), is_standard);
}

RegisterSpecific() [5/6]

void RegisterSpecific ( const std::string &  name, const std::string &  idx, double *  f, const std::string &  doc, bool  is_standard  )

private

Register double variable [useful as we change BaseFloat type].

Definition at line 163 of file parse-options.cc.

References ParseOptions::doc_map_, and ParseOptions::double_map_.

                                                      {
  double_map_[idx] = f;
  std::ostringstream ss;
  ss << doc << " (double, default = " << *f << ")";
  doc_map_[idx] = DocInfo(name, ss.str(), is_standard);
}

RegisterSpecific() [6/6]

void RegisterSpecific ( const std::string &  name, const std::string &  idx, std::string *  s, const std::string &  doc, bool  is_standard  )

private

Register string variable.

Definition at line 174 of file parse-options.cc.

References ParseOptions::doc_map_, and ParseOptions::string_map_.

                                                      {
  string_map_[idx] = s;
  doc_map_[idx] = DocInfo(name, doc + " (string, default = \"" + *s + "\")",
                          is_standard);
}

RegisterStandard()

template void RegisterStandard	(	const std::string &	name,
		T *	ptr,
		const std::string &	doc
	)

This one is used for registering standard parameters of all the programs.

Definition at line 115 of file parse-options.cc.

References ParseOptions::RegisterCommon().

Referenced by ParseOptions::ParseOptions(), ParseOptions::ToDouble(), and ParseOptions::~ParseOptions().

                                                  {
  this->RegisterCommon(name, ptr, doc, true);
}

RegisterTmpl()

template void RegisterTmpl ( const std::string &  name, T *  ptr, const std::string &  doc  )

private

Template to register various variable types, used for program-specific parameters.

Definition at line 88 of file parse-options.cc.

References KALDI_ASSERT, ParseOptions::other_parser_, ParseOptions::prefix_, OptionsItf::Register(), and ParseOptions::RegisterCommon().

Referenced by ParseOptions::GetOptArg(), ParseOptions::Register(), and ParseOptions::ToDouble().

                                                      {
  if (other_parser_ == NULL) {
    this->RegisterCommon(name, ptr, doc, false);
  } else {
    KALDI_ASSERT(prefix_ != "" &&
                 "Cannot use empty prefix when registering with prefix.");
    std::string new_name = prefix_ + '.' + name;  // name becomes prefix.name
    other_parser_->Register(new_name, ptr, doc);
  }
}

SetOption()

bool SetOption ( const std::string &  key, const std::string &  value, bool  has_equal_sign  )

private

Set option with name "key" to "value"; will crash if can't do it.

"has_equal_sign" is used to allow –x for a boolean option x, and –y=, for a string option y.

Definition at line 540 of file parse-options.cc.

References ParseOptions::bool_map_, ParseOptions::double_map_, ParseOptions::float_map_, ParseOptions::int_map_, KALDI_ERR, ParseOptions::string_map_, ParseOptions::ToBool(), ParseOptions::ToDouble(), ParseOptions::ToFloat(), ParseOptions::ToInt(), ParseOptions::ToUint(), and ParseOptions::uint_map_.

Referenced by ParseOptions::GetOptArg(), ParseOptions::Read(), and ParseOptions::ReadConfigFile().

                                                  {
  if (bool_map_.end() != bool_map_.find(key)) {
    if (has_equal_sign && value == "")
      KALDI_ERR << "Invalid option --" << key << "=";
    *(bool_map_[key]) = ToBool(value);
  } else if (int_map_.end() != int_map_.find(key)) {
    *(int_map_[key]) = ToInt(value);
  } else if (uint_map_.end() != uint_map_.find(key)) {
    *(uint_map_[key]) = ToUint(value);
  } else if (float_map_.end() != float_map_.find(key)) {
    *(float_map_[key]) = ToFloat(value);
  } else if (double_map_.end() != double_map_.find(key)) {
    *(double_map_[key]) = ToDouble(value);
  } else if (string_map_.end() != string_map_.find(key)) {
    if (!has_equal_sign)
      KALDI_ERR << "Invalid option --" << key
                << " (option format is --x=y).";
    *(string_map_[key]) = value;
  } else {
    return false;
  }
  return true;
}

SplitLongArg()

void SplitLongArg ( const std::string &  in, std::string *  key, std::string *  value, bool *  has_equal_sign  )

protected

SplitLongArg parses an argument of the form –a=b, –a=, or –a,.

and sets "has_equal_sign" to true if an equals-sign was parsed.. this is needed in order to correctly allow –x for a boolean option x, and –y= for a string option y, and to disallow –x= and –y.

Definition at line 500 of file parse-options.cc.

References KALDI_ASSERT, KALDI_ERR, and ParseOptions::PrintUsage().

Referenced by ParseOptions::Read(), and ParseOptions::ReadConfigFile().

                                                      {
  KALDI_ASSERT(in.substr(0, 2) == "--");  // precondition.
  size_t pos = in.find_first_of('=', 0);
  if (pos == std::string::npos) {  // we allow --option for bools
    // defaults to empty.  We handle this differently in different cases.
    *key = in.substr(2, in.size()-2);  // 2 because starts with --.
    *value = "";
    *has_equal_sign = false;
  } else if (pos == 2) {  // we also don't allow empty keys: --=value
    PrintUsage(true);
    KALDI_ERR << "Invalid option (no key): " << in;
  } else {  // normal case: --option=value
    *key = in.substr(2, pos-2);  // 2 because starts with --.
    *value = in.substr(pos + 1);
    *has_equal_sign = true;
  }
}

ToBool()

bool ToBool ( std::string  str )

private

Definition at line 568 of file parse-options.cc.

References KALDI_ERR, and ParseOptions::PrintUsage().

Referenced by ParseOptions::GetOptArg(), and ParseOptions::SetOption().

                                       {
  std::transform(str.begin(), str.end(), str.begin(), ::tolower);

  // allow "" as a valid option for "true", so that --x is the same as --x=true
  if ((str.compare("true") == 0) || (str.compare("t") == 0)
      || (str.compare("1") == 0) || (str.compare("") == 0)) {
    return true;
  }
  if ((str.compare("false") == 0) || (str.compare("f") == 0)
      || (str.compare("0") == 0)) {
    return false;
  }
  // if it is neither true nor false:
  PrintUsage(true);
  KALDI_ERR << "Invalid format for boolean argument [expected true or false]: "
            << str;
  return false;  // never reached
}

ToDouble()

double ToDouble ( const std::string &  str )

private

Definition at line 609 of file parse-options.cc.

References kaldi::ConvertStringToReal(), KALDI_ERR, ParseOptions::RegisterCommon(), ParseOptions::RegisterStandard(), and ParseOptions::RegisterTmpl().

Referenced by ParseOptions::GetOptArg(), and ParseOptions::SetOption().

                                                  {
  double ret;
  if (!ConvertStringToReal(str, &ret))
    KALDI_ERR << "Invalid floating-point option \"" << str << "\"";
  return ret;
}

ToFloat()

float ToFloat ( const std::string &  str )

private

Definition at line 602 of file parse-options.cc.

References kaldi::ConvertStringToReal(), and KALDI_ERR.

Referenced by ParseOptions::GetOptArg(), and ParseOptions::SetOption().

                                                {
  float ret;
  if (!ConvertStringToReal(str, &ret))
    KALDI_ERR << "Invalid floating-point option \"" << str << "\"";
  return ret;
}

ToInt()

int32 ToInt ( const std::string &  str )

private

Definition at line 588 of file parse-options.cc.

References kaldi::ConvertStringToInteger(), and KALDI_ERR.

Referenced by ParseOptions::GetOptArg(), and ParseOptions::SetOption().

                                              {
  int32 ret;
  if (!ConvertStringToInteger(str, &ret))
    KALDI_ERR << "Invalid integer option \"" << str << "\"";
  return ret;
}

ToUint()

uint32 ToUint ( const std::string &  str )

private

Definition at line 595 of file parse-options.cc.

References kaldi::ConvertStringToInteger(), and KALDI_ERR.

Referenced by ParseOptions::GetOptArg(), and ParseOptions::SetOption().

                                                {
  uint32 ret;
  if (!ConvertStringToInteger(str, &ret))
    KALDI_ERR << "Invalid integer option \"" << str << "\"";
  return ret;
}

Member Data Documentation

argc_

int argc_

private

Definition at line 214 of file parse-options.h.

Referenced by ParseOptions::PrintUsage(), and ParseOptions::Read().

argv_

const char* const* argv_

private

Definition at line 215 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintUsage(), and ParseOptions::Read().

bool_map_

std::map<std::string, bool*> bool_map_

private

Definition at line 184 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintConfig(), ParseOptions::RegisterSpecific(), and ParseOptions::SetOption().

config_

std::string config_

private

variable for the implicit –config parameter

Definition at line 211 of file parse-options.h.

Referenced by ParseOptions::ParseOptions().

doc_map_

DocMapType doc_map_

private

map for the documentation

Definition at line 207 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintConfig(), ParseOptions::PrintUsage(), ParseOptions::RegisterCommon(), and ParseOptions::RegisterSpecific().

double_map_

std::map<std::string, double*> double_map_

private

Definition at line 188 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintConfig(), ParseOptions::RegisterSpecific(), and ParseOptions::SetOption().

float_map_

std::map<std::string, float*> float_map_

private

Definition at line 187 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintConfig(), ParseOptions::RegisterSpecific(), and ParseOptions::SetOption().

help_

bool help_

private

variable for the implicit –help parameter

Definition at line 210 of file parse-options.h.

Referenced by ParseOptions::ParseOptions().

int_map_

std::map<std::string, int32*> int_map_

private

Definition at line 185 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintConfig(), ParseOptions::RegisterSpecific(), and ParseOptions::SetOption().

other_parser_

OptionsItf* other_parser_

private

Definition at line 220 of file parse-options.h.

Referenced by ParseOptions::ParseOptions(), and ParseOptions::RegisterTmpl().

positional_args_

std::vector<std::string> positional_args_

private

Definition at line 212 of file parse-options.h.

Referenced by ParseOptions::GetArg(), ParseOptions::NumArgs(), and ParseOptions::Read().

prefix_

std::string prefix_

private

These members are not normally used.

They are only used when the object is constructed with a prefix

Definition at line 219 of file parse-options.h.

Referenced by ParseOptions::ParseOptions(), and ParseOptions::RegisterTmpl().

print_args_

bool print_args_

private

variable for the implicit –print-args parameter

Definition at line 209 of file parse-options.h.

Referenced by ParseOptions::ParseOptions(), and ParseOptions::Read().

string_map_

std::map<std::string, std::string*> string_map_

private

Definition at line 189 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintConfig(), ParseOptions::RegisterSpecific(), and ParseOptions::SetOption().

uint_map_

std::map<std::string, uint32*> uint_map_

private

Definition at line 186 of file parse-options.h.

Referenced by ParseOptions::DisableOption(), ParseOptions::PrintConfig(), ParseOptions::RegisterSpecific(), and ParseOptions::SetOption().

usage_

const char* usage_

private

Definition at line 213 of file parse-options.h.

Referenced by ParseOptions::PrintUsage().

---

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

• util/parse-options.h
• util/parse-options.cc