CommandLine Class Reference

This class wraps provides and tracks access to command line parameters. More...

#include <CommandLine.h>

Classes
struct	Option

Public Types
enum	ARGUMENT { NONE, OPTIONAL, REQUIRED }
	Type of argument for a given option. More...

Public Member Functions
	CommandLine (int argc, char *argv[])
virtual	~CommandLine ()
void	addCommandLineOptionsFromParams (InputParameters &params)
void	populateInputParams (InputParameters &params)
void	addOption (const std::string &name, Option cli_opt)
bool	search (const std::string &option_name)
	This routine searches the command line for the given option "handle" and returns a boolean indicating whether it was found. More...
template<typename T >
bool	search (const std::string &option_name, T &argument)
void	printUsage () const
	Print the usage info for this command line. More...
int	argc ()
char **	argv ()
void	markHitParamUsed (int argi)
void	markHitParam (int argi)
std::set< int >	unused (const Parallel::Communicator &comm)

Protected Member Functions
template<typename T >
void	setArgument (std::stringstream &stream, T &argument)
	Used to set the argument value, allows specialization. More...

Protected Attributes
std::map< std::string, Option >	_cli_options
	Command line options. More...

Private Attributes
std::set< int >	_used_hiti
std::set< int >	_hiti
int	_argc = 0
char **	_argv = nullptr
std::vector< std::string >	_args

Detailed Description

This class wraps provides and tracks access to command line parameters.

Definition at line 31 of file CommandLine.h.

Member Enumeration Documentation

ARGUMENT

enum CommandLine::ARGUMENT

Type of argument for a given option.

Enumerator
NONE
OPTIONAL
REQUIRED

Definition at line 35 of file CommandLine.h.

  {
    NONE,
    OPTIONAL,
    REQUIRED
  };

Constructor & Destructor Documentation

CommandLine()

CommandLine::CommandLine	(	int	argc,
		char *	argv[]
	)

Definition at line 19 of file CommandLine.C.

                                                : _argc(argc), _argv(argv)
{
  for (int i = 0; i < argc; i++)
  {
    auto arg_value = std::string(argv[i]);

    // Handle using a "="
    if (arg_value.find("=") != std::string::npos)
    {
      std::vector<std::string> arg_split;

      MooseUtils::tokenize(arg_value, arg_split, 1, "=");

      for (auto & arg_piece : arg_split)
        _args.push_back(MooseUtils::trim(arg_piece));
    }
    else
      _args.push_back(arg_value);
  }
}

~CommandLine()

CommandLine::~CommandLine ( )

virtual

Definition at line 40 of file CommandLine.C.

{}

Member Function Documentation

addCommandLineOptionsFromParams()

void CommandLine::addCommandLineOptionsFromParams

(

InputParameters &

params

)

Definition at line 43 of file CommandLine.C.

{
  for (const auto & it : params)
  {
    Option cli_opt;
    std::vector<std::string> syntax;
    std::string orig_name = it.first;

    cli_opt.description = params.getDocString(orig_name);
    if (!params.isPrivate(orig_name))
      // If a param is private then it shouldn't have any command line syntax.
      syntax = params.getSyntax(orig_name);
    cli_opt.cli_syntax = syntax;
    cli_opt.required = false;
    InputParameters::Parameter<bool> * bool_type =
        dynamic_cast<InputParameters::Parameter<bool> *>(it.second);
    if (bool_type)
      cli_opt.argument_type = CommandLine::NONE;
    else
      cli_opt.argument_type = CommandLine::REQUIRED;

    addOption(orig_name, cli_opt);
  }
}

addOption()

void CommandLine::addOption	(	const std::string &	name,
		Option	cli_opt
	)

Definition at line 128 of file CommandLine.C.

Referenced by addCommandLineOptionsFromParams().

{
  for (const auto & stx : cli_opt.cli_syntax)
    cli_opt.cli_switch.push_back(stx.substr(0, stx.find_first_of(" =")));

  _cli_options[name] = cli_opt;
}

argc()

int CommandLine::argc ( )

inline

Definition at line 76 of file CommandLine.h.

Referenced by CommandLine(), and Moose::PetscSupport::petscSetupOutput().

{ return _argc; }

argv()

char** CommandLine::argv ( )

inline

Definition at line 77 of file CommandLine.h.

Referenced by CommandLine(), and Moose::PetscSupport::petscSetupOutput().

{ return _argv; }

markHitParam()

void CommandLine::markHitParam ( int  argi )

inline

Definition at line 83 of file CommandLine.h.

{ _hiti.insert(argi); }

markHitParamUsed()

void CommandLine::markHitParamUsed ( int  argi )

inline

Definition at line 82 of file CommandLine.h.

{ _used_hiti.insert(argi); };

populateInputParams()

void CommandLine::populateInputParams

(

InputParameters &

params

)

Definition at line 69 of file CommandLine.C.

{
  for (const auto & it : params)
  {
    std::string orig_name = it.first;

    if (search(orig_name))
    {
      {
        InputParameters::Parameter<std::string> * string_type =
            dynamic_cast<InputParameters::Parameter<std::string> *>(it.second);
        if (string_type)
        {
          search(orig_name, params.set<std::string>(orig_name));
          continue;
        }

        InputParameters::Parameter<Real> * real_type =
            dynamic_cast<InputParameters::Parameter<Real> *>(it.second);
        if (real_type)
        {
          search(orig_name, params.set<Real>(orig_name));
          continue;
        }

        InputParameters::Parameter<unsigned int> * uint_type =
            dynamic_cast<InputParameters::Parameter<unsigned int> *>(it.second);
        if (uint_type)
        {
          search(orig_name, params.set<unsigned int>(orig_name));
          continue;
        }

        InputParameters::Parameter<int> * int_type =
            dynamic_cast<InputParameters::Parameter<int> *>(it.second);
        if (int_type)
        {
          search(orig_name, params.set<int>(orig_name));
          continue;
        }

        InputParameters::Parameter<bool> * bool_type =
            dynamic_cast<InputParameters::Parameter<bool> *>(it.second);
        if (bool_type)
        {
          search(orig_name, params.set<bool>(orig_name));
          continue;
        }
      }
    }
    else if (params.isParamRequired(orig_name))
      mooseError("Missing required command-line parameter: ",
                 orig_name,
                 "\nDoc String: ",
                 params.getDocString(orig_name));
  }
}

printUsage()

void CommandLine::printUsage

(

)

const

Print the usage info for this command line.

Definition at line 158 of file CommandLine.C.

Referenced by search().

{
  // Grab the first item out of argv
  std::string command(_args[0]);
  command.substr(command.find_last_of("/\\") + 1);

  Moose::out << "Usage: " << command << " [<options>]\n\n"
             << "Options:\n"
             << std::left;

  for (const auto & i : _cli_options)
  {
    if (i.second.cli_syntax.empty())
      continue;

    std::stringstream oss;
    for (unsigned int j = 0; j < i.second.cli_syntax.size(); ++j)
    {
      if (j)
        oss << " ";
      oss << i.second.cli_syntax[j];
    }
    Moose::out << "  " << std::setw(50) << oss.str() << i.second.description << "\n";
  }

  Moose::out << "\nSolver Options:\n"
             << "  See solver manual for details (Petsc or Trilinos)\n";
}

search() [1/2]

bool CommandLine::search

(

const std::string &

option_name

)

This routine searches the command line for the given option "handle" and returns a boolean indicating whether it was found.

If the given option has an argument it is also filled in.

Definition at line 137 of file CommandLine.C.

Referenced by populateInputParams().

{
  std::map<std::string, Option>::iterator pos = _cli_options.find(option_name);
  if (pos != _cli_options.end())
  {
    for (const auto & search_string : pos->second.cli_switch)
      for (auto & arg : _args)
        if (arg == search_string)
          return true;

    if (pos->second.required)
    {
      printUsage();
      mooseError("Required parameter: ", option_name, " missing");
    }
    return false;
  }
  mooseError("Unrecognized option name: ", option_name);
}

search() [2/2]

template<typename T >

bool CommandLine::search	(	const std::string &	option_name,
		T &	argument
	)

Definition at line 133 of file CommandLine.h.

{
  std::map<std::string, Option>::iterator pos = _cli_options.find(option_name);
  if (pos != _cli_options.end())
  {
    for (unsigned int i = 0; i < pos->second.cli_switch.size(); ++i)
    {

      for (size_t j = 0; j < _args.size(); j++)
      {
        auto arg = _args[j];

        if (arg == pos->second.cli_switch[i])
        {
          // "Flag" CLI options are added as Boolean types, when we see them
          // we set the Boolean argument to true
          if (pos->second.argument_type == NONE)
            argument = true;
          else if (j + 1 < _args.size())
          {
            std::stringstream ss;
            ss << _args[j + 1];

            setArgument(ss, argument);
          }
          return true;
        }
      }
    }

    if (pos->second.required)
    {
      Moose::err << "Required parameter: " << option_name << " missing\n";
      printUsage();
    }
    return false;
  }
  mooseError("Unrecognized option name");
}

setArgument()

template<typename T >

void CommandLine::setArgument ( std::stringstream &  stream, T &  argument  )

protected

Used to set the argument value, allows specialization.

Definition at line 122 of file CommandLine.h.

Referenced by search().

{
  stream >> argument;
}

unused()

std::set<int> CommandLine::unused ( const Parallel::Communicator &  comm )

inline

Definition at line 88 of file CommandLine.h.

  {
    comm.set_union(_hiti);
    comm.set_union(_used_hiti);

    std::set<int> unused;
    for (int i : _hiti)
    {
      if (_used_hiti.count(i) == 0)
        unused.insert(i);
    }
    return unused;
  }

Member Data Documentation

_argc

int CommandLine::_argc = 0

private

Definition at line 115 of file CommandLine.h.

Referenced by argc().

_args

std::vector<std::string> CommandLine::_args

private

Definition at line 117 of file CommandLine.h.

Referenced by CommandLine(), printUsage(), and search().

_argv

char** CommandLine::_argv = nullptr

private

Definition at line 116 of file CommandLine.h.

Referenced by argv().

_cli_options

std::map<std::string, Option> CommandLine::_cli_options

protected

Command line options.

Definition at line 110 of file CommandLine.h.

Referenced by addOption(), printUsage(), and search().

_hiti

std::set<int> CommandLine::_hiti

private

Definition at line 114 of file CommandLine.h.

Referenced by markHitParam(), and unused().

_used_hiti

std::set<int> CommandLine::_used_hiti

private

Definition at line 113 of file CommandLine.h.

Referenced by markHitParamUsed(), and unused().

---

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

• include/parser/CommandLine.h
• src/parser/CommandLine.C