CommandLine Class Reference

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

#include <CommandLine.h>

Classes
struct	CommandLineParam
	Stores information pertaining to a command line InputParameter. More...
struct	Entry
	Stores name/value pairs for each command line argument. More...

Public Types
using	ArgumentType = InputParameters::CommandLineMetadata::ArgumentType

Public Member Functions
	CommandLine ()
	CommandLine (int argc, char *argv[])
	CommandLine (const std::vector< std::string > &args)
virtual	~CommandLine ()
void	addArguments (int argc, char *argv[])
	Adds arguments from raw argc and argv. More...
void	addArgument (const std::string &arg)
	Adds a single argument. More...
void	addArguments (const std::vector< std::string > &args)
	Adds arguments from a vector. More...
bool	hasArgument (const std::string &arg) const
void	removeArgument (const std::string &arg)
	Removes an argument that must exist. More...
void	parse ()
	Performs the parsing, which is the combining of arguments into [name, value] pairs. More...
bool	hasParsed () const
std::unique_ptr< CommandLine >	initSubAppCommandLine (const std::string &multiapp_name, const std::string &subapp_name, const std::vector< std::string > &input_cli_args)
	Initializes a new CommandLine for a subapp with a MultiApp named multiapp_name and a subapp named subapp_name. More...
std::string	buildHitParams ()
const std::vector< std::string > &	getArguments ()
void	populateCommandLineParams (InputParameters &params)
	Populates the command line input parameters from params. More...
auto	begin () const
auto	end () const
const std::list< Entry > &	getEntries () const
std::string	getExecutableName () const
std::string	getExecutableNameBase () const
void	printUsage () const
	Print the usage info for this command line. More...
std::vector< std::string >	unusedHitParams (const Parallel::Communicator &comm) const
	Returns the HIT command line arguments that are not used. More...
std::list< Entry >::const_iterator	findCommandLineParam (const std::string &name) const
std::string	formatEntry (const Entry &entry) const
template<typename T >
void	setCommandLineParam (std::list< CommandLine::Entry >::iterator entry_it, const CommandLineParam &param, const std::string &cli_switch, T &value)

Private Member Functions
std::list< Entry > &	getEntries ()
template<typename T >
void	setCommandLineParam (std::list< Entry >::iterator entry_it, const CommandLineParam &param, const std::string &cli_switch, T &value)
	Sets an InputParameters command line option at value. More...
std::list< Entry >::iterator	findCommandLineParam (const std::string &name)

Private Attributes
std::vector< std::string >	_argv
	Storage for the raw argv. More...
std::list< Entry >	_entries
	The parsed command line entries (arguments split into name value pairs) This is a list because it is necessary to combine Entry objects later on. More...
std::map< std::string, CommandLineParam >	_command_line_params
	The command line parameters, added by populateCommandLineParams() More...
bool	_has_parsed = false
	Whether or not the Parser has parsed yet. More...
bool	_command_line_params_populated = false
	Whether or not command line parameters have been populated. More...

Detailed Description

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

Definition at line 29 of file CommandLine.h.

Member Typedef Documentation

ArgumentType

using CommandLine::ArgumentType = InputParameters::CommandLineMetadata::ArgumentType

Definition at line 32 of file CommandLine.h.

Constructor & Destructor Documentation

CommandLine() [1/3]

CommandLine::CommandLine

(

)

Definition at line 27 of file CommandLine.C.

{}

CommandLine() [2/3]

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

Definition at line 28 of file CommandLine.C.

{ addArguments(argc, argv); }

CommandLine() [3/3]

CommandLine::CommandLine

(

const std::vector< std::string > &

args

)

Definition at line 29 of file CommandLine.C.

{ addArguments(args); }

~CommandLine()

CommandLine::~CommandLine ( )

virtual

Definition at line 199 of file CommandLine.C.

{}

Member Function Documentation

addArgument()

void CommandLine::addArgument

(

const std::string &

arg

)

Adds a single argument.

Definition at line 39 of file CommandLine.C.

Referenced by addArguments().

{
  mooseAssert(!hasParsed(), "Has already parsed");
  _argv.push_back(arg);
}

addArguments() [1/2]

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

Adds arguments from raw argc and argv.

Definition at line 32 of file CommandLine.C.

Referenced by CommandLine().

{
  for (int i = 0; i < argc; i++)
    addArgument(argv[i]);
}

addArguments() [2/2]

void CommandLine::addArguments

(

const std::vector< std::string > &

args

)

Adds arguments from a vector.

Definition at line 46 of file CommandLine.C.

{
  for (const auto & arg : args)
    addArgument(arg);
}

begin()

auto CommandLine::begin ( ) const

inline

Returns

An iterator to the beginning of the options

Definition at line 145 of file CommandLine.h.

Referenced by initSubAppCommandLine(), and parse().

{ return _entries.begin(); }

buildHitParams()

std::string CommandLine::buildHitParams

(

)

Returns

The parsed HIT command line parameters per the command line arguments.

This will also mark all found HIT parameters as used.

Definition at line 240 of file CommandLine.C.

{
  mooseAssert(_command_line_params_populated, "Must populate command line params first");

  std::vector<std::string> params;

  // Collect all hit parameters that aren't for subapps
  for (auto & entry : getEntries())
    if (entry.hit_param && !entry.subapp_name)
    {
      mooseAssert(entry.value, "Should have a value");
      mooseAssert(entry.value_separator, "Should have value separator");
      mooseAssert(*entry.value_separator == "=", "Should be an equals");

      const std::string name_and_equals = entry.name + *entry.value_separator;
      std::string arg = name_and_equals;
      // In the case of empty values, we want them to be empty to hit
      if (entry.value->empty())
        arg += "''";
      else
        arg += *entry.value;

      // We could have issues with bash eating strings, so the first try
      // gives us a chance to wrap the value in quotes
      try
      {
        hit::check("CLI_ARG", arg);
      }
      catch (hit::ParseError & err)
      {
        // bash might have eaten quotes around a hit string value or vector
        // so try quoting after the "=" and reparse
        arg = name_and_equals + "'" + *entry.value + "'";
        try
        {
          hit::check("CLI_ARG", arg);
        }
        // At this point, we've failed to fix it
        catch (hit::ParseError & err)
        {
          mooseError("Failed to parse HIT in command line argument '", arg, "'\n\n", err.what());
        }
      }

      // Append to the total output
      params.push_back(arg);
      // Consider this parameter used
      entry.used = true;
    }

  return MooseUtils::stringJoin(params, " ");
}

end()

auto CommandLine::end ( ) const

inline

Returns

An iterator to the end of the options

Definition at line 149 of file CommandLine.h.

Referenced by initSubAppCommandLine(), and parse().

{ return _entries.end(); }

findCommandLineParam() [1/2]

std::list< CommandLine::Entry >::const_iterator CommandLine::findCommandLineParam

(

const std::string &

name

)

const

Returns

The entry iterator for the command line arguments for the command line input parameter with name name, if any.

Definition at line 463 of file CommandLine.C.

Referenced by populateCommandLineParams().

{
  const auto find_param = _command_line_params.find(name);
  if (find_param == _command_line_params.end())
    mooseError("CommandLine::findCommandLineParam(): The parameter '",
               name,
               "' is not a command line parameter");

  // Search for the last thing that matches a switch from this param
  const auto & param = find_param->second;
  for (auto rit = _entries.rbegin(); rit != _entries.rend(); ++rit)
    for (const auto & search_switch : param.metadata.switches)
      if (rit->name == search_switch)
        return --(rit.base());

  return getEntries().end();
}

findCommandLineParam() [2/2]

std::list< CommandLine::Entry >::iterator CommandLine::findCommandLineParam ( const std::string &  name )

private

Returns

The entry iterator for the command line arguments for the command line input parameter with name name, if any.

Definition at line 482 of file CommandLine.C.

{
  const auto it = std::as_const(*this).findCommandLineParam(name);
  // Easy way to go from a const iterator -> non-const iterator
  return _entries.erase(it, it);
}

formatEntry()

std::string CommandLine::formatEntry

(

const Entry &

entry

)

const

Returns

A formatted representation of the given command line entry

Definition at line 490 of file CommandLine.C.

{
  std::stringstream oss;
  oss << entry.name;
  if (entry.value)
  {
    const auto q = (*entry.value).find(" ") != std::string::npos ? "'" : "";
    oss << *entry.value_separator << q << *entry.value << q;
  }
  return oss.str();
}

getArguments()

const std::vector<std::string>& CommandLine::getArguments ( )

inline

Returns

The raw argv arguments as a vector

Definition at line 132 of file CommandLine.h.

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

{ return _argv; }

getEntries() [1/2]

const std::list< CommandLine::Entry > & CommandLine::getEntries

(

)

const

Returns

The combined argument entries

Definition at line 186 of file CommandLine.C.

Referenced by buildHitParams(), findCommandLineParam(), initSubAppCommandLine(), and unusedHitParams().

{
  mooseAssert(hasParsed(), "Has not parsed");
  return _entries;
}

getEntries() [2/2]

std::list< CommandLine::Entry > & CommandLine::getEntries ( )

private

Returns

The combined argument entries

Definition at line 193 of file CommandLine.C.

{
  mooseAssert(hasParsed(), "Has not parsed");
  return _entries;
}

getExecutableName()

std::string CommandLine::getExecutableName

(

)

const

Returns

The executable name.

Definition at line 384 of file CommandLine.C.

Referenced by getExecutableNameBase(), and printUsage().

{
  mooseAssert(_entries.size() > 0, "Does not have any entries");

  // Grab the first item out of argv
  const auto & command = _entries.begin()->name;
  return command.substr(command.find_last_of("/\\") + 1);
}

getExecutableNameBase()

std::string CommandLine::getExecutableNameBase

(

)

const

Returns

The exectuable name base (the name without the -[opt,oprof,devel,dbg])

Definition at line 394 of file CommandLine.C.

{
  auto name = getExecutableName();
  name = name.substr(0, name.find_last_of("-"));
  if (name.find_first_of("/") != std::string::npos)
    name = name.substr(name.find_first_of("/") + 1, std::string::npos);
  return name;
}

hasArgument()

bool CommandLine::hasArgument

(

const std::string &

arg

)

const

Returns

Whether or not the raw argument arg is contained

Definition at line 53 of file CommandLine.C.

{
  return std::find(_argv.begin(), _argv.end(), arg) != _argv.end();
}

hasParsed()

bool CommandLine::hasParsed ( ) const

inline

Returns

Whether or not the arguments have been parsed

Definition at line 105 of file CommandLine.h.

Referenced by addArgument(), getEntries(), parse(), and removeArgument().

{ return _has_parsed; }

initSubAppCommandLine()

std::unique_ptr< CommandLine > CommandLine::initSubAppCommandLine	(	const std::string &	multiapp_name,
		const std::string &	subapp_name,
		const std::vector< std::string > &	input_cli_args
	)

Initializes a new CommandLine for a subapp with a MultiApp named multiapp_name and a subapp named subapp_name.

The arguments input_cli_args are the additional arguments to apply to the subapp, such as those that have been specified in the MultiApp params (cli_args param).

This will apply all global parameters from this parent application and all HIT CLI parameters that have the same.

Definition at line 202 of file CommandLine.C.

{
  mooseAssert(MooseUtils::beginsWith(subapp_name, multiapp_name),
              "Name for the subapp should begin with the multiapp");

  std::vector<std::string> subapp_args;

  // Start with the arguments from the input file; we want these to take the
  // lowest priority so we put them first. Also trim extra whitespace
  for (const auto & arg : input_cli_args)
    subapp_args.push_back(MooseUtils::removeExtraWhitespace(arg));

  // Pull out all of the arguments that are relevant to this multiapp from the parent
  // Note that the 0th argument of the main app, i.e., the name used to invoke the program,
  // is neither a global entry nor a subapp entry and, as such, won't be passed on
  for (auto & entry : as_range(getEntries().begin(), getEntries().end()))
    if (entry.global || (entry.subapp_name && (*entry.subapp_name == multiapp_name ||
                                               *entry.subapp_name == subapp_name)))
    {
      if (entry.hit_param)
      {
        // Append : to the beginning if this is global and should be passed to all
        const std::string prefix = entry.global ? ":" : "";
        // Apply the param, but without the subapp name
        subapp_args.push_back(prefix + entry.name + *entry.value_separator + *entry.value);
        // Mark this entry as used as a child has consumed it
        entry.used = true;
      }
      else
        subapp_args.insert(subapp_args.end(), entry.raw_args.begin(), entry.raw_args.end());
    }

  return std::make_unique<CommandLine>(subapp_args);
}

parse()

void CommandLine::parse

(

)

Performs the parsing, which is the combining of arguments into [name, value] pairs.

Must be called before extracing anything from the CommandLine.

Definition at line 69 of file CommandLine.C.

Referenced by AppFactory::createAppShared(), and Moose::createMooseApp().

{
  mooseAssert(!hasParsed(), "Has already parsed");
  mooseAssert(_entries.empty(), "Should be empty");

  // Whether or not we have a entry that accepts values
  bool has_value_accepting_entry = false;

  // Helper for adding an entry
  auto add_entry = [this](const auto & name) -> Entry &
  {
    auto & entry = _entries.emplace_back();
    entry.name = name;
    return entry;
  };

  // Work through each argument
  for (const auto i : index_range(_argv))
  {
    const auto & arg = _argv[i];
    const auto begins_with_dash = MooseUtils::beginsWith(arg, "-");
    std::string subapp_prefix, subapp_name, hit_path, hit_value;

    // MultiApp syntax with a non-hit option
    if (!begins_with_dash && std::regex_search(arg, std::regex("^(([^\\s\n\t[\\]\\/=#&:]+):)[-]")))
    {
      mooseError("The MultiApp command line argument '",
                 arg,
                 "' sets a command line option.\nMultiApp command line arguments can only be "
                 "used for setting HIT parameters.");
    }
    // Match HIT CLI syntax (including for multiapps with the prefix)
    // For subapp hit cli syntax (i.e, <subname>:<value)), we will store the
    // subapp names to be stripped away in initSubAppCommandLine() as they
    // are passed down
    else if (!begins_with_dash &&
             pcrecpp::RE("(([^\\s\n\t[\\]\\/=#&:]+)?:)?((?:[^\\s\n\t[\\]=#&]+\\/"
                         ")?(?:[^\\s\n\t=#$'\"]+))=([^#]+)?")
                 .FullMatch(arg, &subapp_prefix, &subapp_name, &hit_path, &hit_value))
    {
      auto & entry = add_entry(hit_path);
      if (subapp_prefix.size())
      {
        if (subapp_name.empty()) // :param=value; means apply to all
          entry.global = true;
        else
          entry.subapp_name = subapp_name;
      }
      entry.value = MooseUtils::removeExtraWhitespace(hit_value);
      entry.value_separator = "=";
      entry.raw_args.push_back(arg);
      entry.hit_param = true;
      has_value_accepting_entry = false;
    }
    // Has an = sign in it, so we have a name=value (non-HIT)
    else if (const auto find_equals = arg.find("="); find_equals != std::string::npos)
    {
      const auto begin = arg.substr(0, find_equals);
      const auto end = arg.substr(find_equals + 1);
      auto & entry = add_entry(begin);
      entry.value = MooseUtils::removeExtraWhitespace(end);
      entry.value_separator = "=";
      entry.raw_args.push_back(arg);
      has_value_accepting_entry = false;
    }
    // Begins with dash(es) and a character, so a new argument. We pass on
    // everything else that starts with a dash as a value, so the error
    // will be associated with the value before it
    else if (std::regex_search(arg, std::regex("^\\-+[a-zA-Z]")))
    {
      auto & entry = add_entry(arg);
      entry.raw_args.push_back(arg);
      has_value_accepting_entry = true;
    }
    // Should be tagging on a value to the previous argument
    else
    {
      // First one is the executable
      if (i == 0)
      {
        auto & entry = add_entry(arg);
        entry.raw_args.push_back(arg);
        continue;
      }

      // Throw an error if this a value and we don't have anything to apply it to
      if (!has_value_accepting_entry)
      {
        std::stringstream err;
        err << "The command line argument '" << arg
            << "' is not applied to an option and is not a HIT parameter.";
        // Maybe they meant to apply it to the previous thing
        // Example: "-i foo.i bar.i" would suggest "-i 'foo.i bar.i'"
        if (i > 0 && _entries.back().value)
        {
          err << "\n\nDid you mean to combine this argument with the previous argument, such "
                 "as:\n\n  "
              << _entries.back().name << *_entries.back().value_separator << "'"
              << *_entries.back().value << " " << arg << "'\n";
        }
        mooseError(err.str());
      }

      auto & entry = _entries.back();
      if (entry.value)
        *entry.value += " " + MooseUtils::removeExtraWhitespace(arg);
      else
        entry.value = MooseUtils::removeExtraWhitespace(arg);
      entry.value_separator = " ";
      entry.raw_args.push_back(arg);
    }
  }

  _has_parsed = true;
}

populateCommandLineParams()

void CommandLine::populateCommandLineParams

(

InputParameters &

params

)

Populates the command line input parameters from params.

Will throw errors when conversions fail and may combine entires in _entries if some are found that can be combined.

Definition at line 294 of file CommandLine.C.

Referenced by AppFactory::createAppShared(), and Moose::createMooseApp().

{
  mooseAssert(!_command_line_params_populated, "Already populated");

  // Set the metadata for each command line parameter
  // We set this separately so that it can be used later to print usage
  std::map<std::string, std::string> switch_param_map;
  for (const auto & name_value_pair : params)
  {
    const auto & name = name_value_pair.first;
    if (const auto metadata = params.queryCommandLineMetadata(name))
    {
      auto it_inserted_pair = _command_line_params.emplace(name, CommandLineParam());
      auto & option = it_inserted_pair.first->second;

      option.description = params.getDocString(name);
      option.metadata = *metadata;

      // Make sure that one switch isn't specified for multiple parameters
      for (const auto & cli_switch : option.metadata.switches)
        if (const auto it_inserted_pair = switch_param_map.emplace(cli_switch, name);
            !it_inserted_pair.second)
          mooseError("The command line options '",
                     it_inserted_pair.first->second,
                     "' and '",
                     name,
                     "' both declare the command line switch '",
                     cli_switch,
                     "'");
    }
  }

  // Set each paramter that we have a value for
  for (const auto & [name, param] : _command_line_params)
  {
    auto entry_it = findCommandLineParam(name);
    if (entry_it != _entries.end())
    {
      auto & entry = *entry_it;
      mooseAssert(!entry.subapp_name, "Should not be for a subapp");

      bool found = false;
#define trySetParameter(type)                                                                      \
  if (!found && params.have_parameter<type>(name))                                                 \
  {                                                                                                \
    static_assert(InputParameters::isValidCommandLineType<type>::value, "Not a supported value");  \
    auto & value = params.set<type>(name);                                                         \
    setCommandLineParam(entry_it, param, entry.name, value);                                       \
    found = true;                                                                                  \
  }

      trySetParameter(std::string);
      trySetParameter(std::vector<std::string>);
      trySetParameter(Real);
      trySetParameter(unsigned int);
      trySetParameter(int);
      trySetParameter(bool);
      trySetParameter(MooseEnum);
#undef trySetParameter

      mooseAssert(found, "Should have been found");

      // If we found this parameter, that means we set it and we should mark in the
      // InputParameters that it is set so that isParamSetByUser() returns true for this param
      params.commandLineParamSet(name, {});

      // If this parameter is global, mark its entry as global
      if (param.metadata.global)
        entry.global = true;

      // If the arg is of the form "--key=value", PETSc will recognize it as an unused
      // argument. That is, setting "--key" as a known command line argument is not
      // sufficient for PETSc to consider "--key=value" as known. Thus, we explicitly
      // add "--key=value" args as known when we come across them.
      if (entry.value_separator && *entry.value_separator == "=")
      {
        mooseAssert(entry.raw_args.size() == 1, "Should have one value");
        libMesh::add_command_line_name(entry.raw_args[0]);
      }
    }
    // If we didn't find it and it is required, we need to error
    else if (param.metadata.required)
      mooseError(
          "Missing required command-line parameter: ", name, "\nDoc string: ", param.description);
  }

  _command_line_params_populated = true;
}

printUsage()

void CommandLine::printUsage

(

)

const

Print the usage info for this command line.

Definition at line 404 of file CommandLine.C.

{
  Moose::out << "Usage: " << getExecutableName() << " [<options>]\n\n";

  std::size_t max_len = 0;
  for (const auto & name_option_pair : _command_line_params)
    max_len = std::max(max_len, name_option_pair.second.metadata.syntax.size());

  const auto output_options = [this, &max_len](const bool global)
  {
    Moose::out << (global ? "Global " : "") << "Options:\n" << std::left;
    for (const auto & name_option_pair : _command_line_params)
    {
      const auto & option = name_option_pair.second;
      if (option.metadata.syntax.empty() || option.metadata.global != global)
        continue;

      Moose::out << "  " << std::setw(max_len + 2) << option.metadata.syntax << option.description
                 << "\n";
    }
    Moose::out << "\n";
  };

  output_options(false);
  output_options(true);

  Moose::out << "Solver Options:\n"
             << "  See PETSc manual for details" << std::endl;

  // If we get here, we are not running a simulation and should silence petsc's unused options
  // warning
  Moose::PetscSupport::setSinglePetscOption("-options_left", "0");
}

removeArgument()

void CommandLine::removeArgument

(

const std::string &

arg

)

Removes an argument that must exist.

Definition at line 59 of file CommandLine.C.

{
  mooseAssert(!hasParsed(), "Has already parsed");
  auto it = std::find(_argv.begin(), _argv.end(), arg);
  if (it == _argv.end())
    mooseError("CommandLine::removeArgument(): The argument '", arg, "' does not exist");
  _argv.erase(it);
}

setCommandLineParam() [1/2]

template<typename T >

void CommandLine::setCommandLineParam ( std::list< Entry >::iterator  entry_it, const CommandLineParam &  param, const std::string &  cli_switch, T &  value  )

private

Sets an InputParameters command line option at value.

Will report an error if string -> value conversions fail or if the parameter requires a value and one was not found.

Parameters

entry_it	Iterator to the Entry object that we're extracting from
param	The internal metadata for the command line parameter
cli_switch	The command line switch for the parameter (-t, –timing, etc)
value	The value that we want to fill into

setCommandLineParam() [2/2]

template<typename T >

void CommandLine::setCommandLineParam	(	std::list< CommandLine::Entry >::iterator	entry_it,
		const CommandLineParam &	param,
		const std::string &	cli_switch,
		T &	value
	)

Definition at line 240 of file CommandLine.h.

{
  auto & entry = *entry_it;
  const auto required = param.metadata.argument_type == ArgumentType::REQUIRED;

  // Mark this entry as used
  entry.used = true;

  // Option doesn't have any arguments (boolean)
  if constexpr (std::is_same_v<bool, T>)
  {
    mooseAssert(param.metadata.argument_type == ArgumentType::NONE, "Incorrect argument type");

    if (entry.value)
      mooseError("The command line option '",
                 cli_switch,
                 "' is a boolean and does not support a value but the value '",
                 *entry.value,
                 "' was provided.\nDoc string: ",
                 param.description);
    value = true;
  }
  // Option has arguments
  else
  {
    mooseAssert(param.metadata.argument_type != ArgumentType::NONE, "Incorrect argument type");

    // Helper for setting a value depending on its type and also throwing a useful
    // error when the conversion fails
    const auto set_value = [&cli_switch](const std::string & from, auto & value)
    {
      using type = typename std::remove_reference<decltype(value)>::type;

      // Keep track of and change the throw on error characteristics so that
      // we can catch parsing errors for the argument
      const auto throw_on_error_orig = Moose::_throw_on_error;
      Moose::_throw_on_error = true;

      try
      {
        if constexpr (std::is_same_v<type, std::string> || std::is_same_v<type, MooseEnum>)
          value = from;
        else
          value = MooseUtils::convert<type>(from, true);
      }
      catch (std::exception & e)
      {
        Moose::_throw_on_error = throw_on_error_orig;
        mooseError("While parsing command line option '",
                   cli_switch,
                   "' with value '",
                   from,
                   "':\n\n",
                   e.what());
      }

      Moose::_throw_on_error = throw_on_error_orig;
    };

    // If a value doesn't exist, check the next argument to see if it
    // would work. This is needed for when we have argument values that
    // have = signs that get split. For example:
    // "--required-capabilities 'petsc>=3.11'" would get split into:
    //   - "--required-capabilities" with no value
    //   - "petsc>" with value "3.11"
    // which we want to re-combine into
    //   - "--required-capabilities" with value "petsc>=3.11"
    if (!entry.value)
    {
      auto next_entry_it = std::next(entry_it);
      if (next_entry_it != _entries.end())
      {
        const auto & next_entry = *next_entry_it;
        if (!next_entry.used &&                    // isn't already used
            (required || !next_entry.hit_param) && // if required, get the last value. if not, get
                                                   // it if it's not a hit param
            !MooseUtils::beginsWith(next_entry.name, "-") && // doesn't start with a -
            next_entry.value_separator &&                    // has a separator
            *next_entry.value_separator == "=" &&            // that separator is =
            next_entry.value)                                // and has a value after the =
        {
          const auto & next_entry = *next_entry_it;
          // Merge with the next Entry object and remove said next object
          entry.value = next_entry.name + *next_entry.value_separator + *next_entry.value;
          entry.raw_args.insert(
              entry.raw_args.end(), next_entry.raw_args.begin(), next_entry.raw_args.end());
          _entries.erase(next_entry_it);
        }
      }
    }

    // If we have a value, set the parameter to it
    if (entry.value)
    {
      // For vector<string>, we need to unpack the values
      if constexpr (std::is_same_v<T, std::vector<std::string>>)
      {
        std::vector<std::string> split_values;
        MooseUtils::tokenize(*entry.value, split_values, 1, " ");
        value.resize(split_values.size());
        for (const auto i : index_range(split_values))
          set_value(split_values[i], value[i]);
      }
      // For everything else, we can set them directly
      else
        set_value(*entry.value, value);
    }
    // No value, but one is required
    else if (param.metadata.argument_type == ArgumentType::REQUIRED)
      mooseError("The command line option '",
                 cli_switch,
                 "' requires a value and one was not provided.\nDoc string: ",
                 param.description);
  }
}

unusedHitParams()

std::vector< std::string > CommandLine::unusedHitParams

(

const Parallel::Communicator &

comm

)

const

Returns the HIT command line arguments that are not used.

The HIT command line arguments are considered used when they are accumulated in buildHitParams().

The commmunicator is needed because we need to sync this in parallel due to the fact that sub apps could only be created on a subset of processors.

Definition at line 439 of file CommandLine.C.

{
  libmesh_parallel_only(comm);

  std::vector<const Entry *> hit_params;
  std::vector<std::size_t> use_count;
  for (const auto & entry : getEntries())
    if (entry.hit_param)
    {
      hit_params.push_back(&entry);
      use_count.push_back(entry.used ? 1 : 0);
    }

  mooseAssert(comm.verify(use_count.size()), "Inconsistent HIT params across procs");
  comm.sum(use_count);

  std::vector<std::string> unused;
  for (const auto i : index_range(use_count))
    if (use_count[i] == 0)
      unused.push_back(hit_params[i]->raw_args[0]);
  return unused;
}

Member Data Documentation

_argv

std::vector<std::string> CommandLine::_argv

private

Storage for the raw argv.

Definition at line 223 of file CommandLine.h.

Referenced by addArgument(), getArguments(), hasArgument(), parse(), and removeArgument().

_command_line_params

std::map<std::string, CommandLineParam> CommandLine::_command_line_params

private

The command line parameters, added by populateCommandLineParams()

Definition at line 230 of file CommandLine.h.

Referenced by findCommandLineParam(), populateCommandLineParams(), and printUsage().

_command_line_params_populated

bool CommandLine::_command_line_params_populated = false

private

Whether or not command line parameters have been populated.

Definition at line 235 of file CommandLine.h.

Referenced by buildHitParams(), and populateCommandLineParams().

_entries

std::list<Entry> CommandLine::_entries

private

The parsed command line entries (arguments split into name value pairs) This is a list because it is necessary to combine Entry objects later on.

Definition at line 227 of file CommandLine.h.

Referenced by begin(), end(), findCommandLineParam(), getEntries(), getExecutableName(), parse(), populateCommandLineParams(), and setCommandLineParam().

_has_parsed

bool CommandLine::_has_parsed = false

private

Whether or not the Parser has parsed yet.

Definition at line 233 of file CommandLine.h.

Referenced by hasParsed(), and parse().

---

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

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