www.mooseframework.org
Classes | Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Attributes | List of all members
CommandLine Class Reference

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

#include <CommandLine.h>

Classes

struct  Option
 

Public Types

using ArgumentType = InputParameters::CommandLineMetadata::ArgumentType
 

Public Member Functions

 CommandLine ()
 
 CommandLine (int argc, char *argv[])
 
 CommandLine (const CommandLine &other)
 
virtual ~CommandLine ()
 
void addArguments (int argc, char *argv[])
 
void addArgument (std::string)
 
void initForMultiApp (const std::string &)
 Removes multiapp parameters not associated with the supplied name. More...
 
const std::vector< std::string > & getArguments ()
 Return the raw argv arguments as a vector. More...
 
void addCommandLineOptionsFromParams (const 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)
 
template<typename T >
bool search (const std::string &option_name, std::vector< T > &argument)
 
std::vector< std::string >::const_iterator find (const std::string &option_name) const
 Returns an iterator to the underlying argument vector to the position of the option or end if the option is not on the command line. More...
 
std::vector< std::string >::const_iterator begin () const
 
std::vector< std::string >::const_iterator end () const
 
std::string getExecutableName () const
 Get the executable name. More...
 
std::string getExecutableNameBase () const
 Get the exectuable name base (the name without the -[opt,oprof,devel,dbg]) More...
 
void printUsage () const
 Print the usage info for this command line. More...
 
void markHitParamUsed (int argi)
 
void markHitParam (int argi)
 
std::set< intunused (const Parallel::Communicator &comm)
 

Protected Member Functions

template<typename T >
void setArgument (std::stringstream &stream, T &argument)
 Helper for setting the argument value, allows specialization. More...
 
template<typename T >
void setArgument (std::stringstream &stream, T &argument, const std::string &cli_switch)
 Helper for setting the argument value; catches errors so we can provide more context. More...
 
template<>
void setArgument (std::stringstream &stream, MooseEnum &argument)
 
template<>
void setArgument (std::stringstream &stream, MooseEnum &argument)
 

Protected Attributes

std::map< std::string, Option_cli_options
 Command line options. More...
 

Private Attributes

std::set< int_used_hiti
 indices of CLI args that have been marked as used More...
 
std::set< int_hiti
 indices of CLI args that are HIT syntax parameters More...
 
std::vector< std::string > _argv
 Storage for the raw argv. More...
 
std::vector< std::string > _args
 

Detailed Description

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

Definition at line 33 of file CommandLine.h.

Member Typedef Documentation

◆ ArgumentType

Definition at line 36 of file CommandLine.h.

Constructor & Destructor Documentation

◆ CommandLine() [1/3]

CommandLine::CommandLine ( )

Definition at line 23 of file CommandLine.C.

23 {}

◆ CommandLine() [2/3]

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

Definition at line 25 of file CommandLine.C.

25 { addArguments(argc, argv); }
void addArguments(int argc, char *argv[])
Definition: CommandLine.C:37

◆ CommandLine() [3/3]

CommandLine::CommandLine ( const CommandLine other)

Definition at line 27 of file CommandLine.C.

28  : _cli_options(other._cli_options),
29  _used_hiti(other._used_hiti),
30  _hiti(other._hiti),
31  _argv(other._argv),
32  _args(other._args)
33 {
34 }
std::map< std::string, Option > _cli_options
Command line options.
Definition: CommandLine.h:156
std::set< int > _hiti
indices of CLI args that are HIT syntax parameters
Definition: CommandLine.h:163
std::vector< std::string > _argv
Storage for the raw argv.
Definition: CommandLine.h:166
std::set< int > _used_hiti
indices of CLI args that have been marked as used
Definition: CommandLine.h:160
std::vector< std::string > _args
Definition: CommandLine.h:168

◆ ~CommandLine()

CommandLine::~CommandLine ( )
virtual

Definition at line 64 of file CommandLine.C.

64 {}

Member Function Documentation

◆ addArgument()

void CommandLine::addArgument ( std::string  arg)

Definition at line 44 of file CommandLine.C.

Referenced by addArguments().

45 {
46  _argv.push_back(arg);
47 
48  auto arg_value = std::string(arg);
49 
50  // Handle using a "="
51  if (arg_value.find("=") != std::string::npos)
52  {
53  std::vector<std::string> arg_split;
54 
55  MooseUtils::tokenize(arg_value, arg_split, 1, "=");
56 
57  for (auto & arg_piece : arg_split)
58  _args.push_back(MooseUtils::trim(arg_piece));
59  }
60  else
61  _args.push_back(arg_value);
62 }
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
Definition: MooseUtils.h:779
std::vector< std::string > _argv
Storage for the raw argv.
Definition: CommandLine.h:166
std::string trim(const std::string &str, const std::string &white_space=" \\\)
Standard scripting language trim function.
Definition: MooseUtils.C:214
std::vector< std::string > _args
Definition: CommandLine.h:168

◆ addArguments()

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

Definition at line 37 of file CommandLine.C.

Referenced by CommandLine().

38 {
39  for (int i = 0; i < argc; i++)
40  addArgument(argv[i]);
41 }
void addArgument(std::string)
Definition: CommandLine.C:44

◆ addCommandLineOptionsFromParams()

void CommandLine::addCommandLineOptionsFromParams ( const InputParameters params)

Definition at line 116 of file CommandLine.C.

117 {
118  for (const auto & name_value_pair : params)
119  {
120  const auto & name = name_value_pair.first;
121  if (params.isCommandLineParameter(name))
122  {
123  Option cli_opt;
124  cli_opt.description = params.getDocString(name);
125  cli_opt.cli_syntax = params.getCommandLineSyntax(name);
126  cli_opt.argument_type = params.getCommandLineArgumentType(name);
127  cli_opt.required = false;
128  addOption(name, cli_opt);
129  }
130  }
131 }
std::string name(const ElemQuality q)
void addOption(const std::string &name, Option cli_opt)
Definition: CommandLine.C:172

◆ addOption()

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

Definition at line 172 of file CommandLine.C.

Referenced by addCommandLineOptionsFromParams().

173 {
174  for (const auto & stx : cli_opt.cli_syntax)
175  cli_opt.cli_switch.push_back(stx.substr(0, stx.find_first_of(" =")));
176 
177  _cli_options[name] = cli_opt;
178 }
std::string name(const ElemQuality q)
std::map< std::string, Option > _cli_options
Command line options.
Definition: CommandLine.h:156

◆ begin()

std::vector< std::string >::const_iterator CommandLine::begin ( ) const

Definition at line 200 of file CommandLine.C.

201 {
202  return _args.begin();
203 }
std::vector< std::string > _args
Definition: CommandLine.h:168

◆ end()

std::vector< std::string >::const_iterator CommandLine::end ( ) const

Definition at line 206 of file CommandLine.C.

207 {
208  return _args.end();
209 }
std::vector< std::string > _args
Definition: CommandLine.h:168

◆ find()

std::vector< std::string >::const_iterator CommandLine::find ( const std::string &  option_name) const

Returns an iterator to the underlying argument vector to the position of the option or end if the option is not on the command line.

Definition at line 181 of file CommandLine.C.

182 {
183  auto pos = _cli_options.find(option_name);
184  auto it = _args.end();
185 
186  if (pos != _cli_options.end())
187  {
188  for (const auto & search_string : pos->second.cli_switch)
189  {
190  auto it = std::find(_args.begin(), _args.end(), search_string);
191  if (it != _args.end())
192  return it;
193  }
194  }
195 
196  return it;
197 }
std::map< std::string, Option > _cli_options
Command line options.
Definition: CommandLine.h:156
std::vector< std::string > _args
Definition: CommandLine.h:168

◆ getArguments()

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

Return the raw argv arguments as a vector.

Definition at line 71 of file CommandLine.h.

Referenced by Moose::PetscSupport::petscSetupOutput().

71 { return _argv; }
std::vector< std::string > _argv
Storage for the raw argv.
Definition: CommandLine.h:166

◆ getExecutableName()

std::string CommandLine::getExecutableName ( ) const

Get the executable name.

Definition at line 233 of file CommandLine.C.

Referenced by getExecutableNameBase(), and printUsage().

234 {
235  // Grab the first item out of argv
236  std::string command(_args[0]);
237  return command.substr(command.find_last_of("/\\") + 1);
238 }
std::vector< std::string > _args
Definition: CommandLine.h:168

◆ getExecutableNameBase()

std::string CommandLine::getExecutableNameBase ( ) const

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

Definition at line 241 of file CommandLine.C.

242 {
243  auto name = getExecutableName();
244  name = name.substr(0, name.find_last_of("-"));
245  if (name.find_first_of("/") != std::string::npos)
246  name = name.substr(name.find_first_of("/") + 1, std::string::npos);
247  return name;
248 }
std::string name(const ElemQuality q)
std::string getExecutableName() const
Get the executable name.
Definition: CommandLine.C:233

◆ initForMultiApp()

void CommandLine::initForMultiApp ( const std::string &  subapp_full_name)

Removes multiapp parameters not associated with the supplied name.

When a sub-application is created the CommandLine object from the master application is copied and supplied to the sub-app. This method cleans up the copy so it is ready to be used for a sub-application by removing parameters that are not associated with the provided sub-application name.

See MultiApp::createApp

Definition at line 67 of file CommandLine.C.

68 {
69  // Get the name and number for the current sub-application
70  std::string sub_name;
71  int sub_num = std::numeric_limits<int>::min(); // this initial value should never be used
72  pcrecpp::RE("(\\S*?)(\\d*)").FullMatch(subapp_full_name, &sub_name, &sub_num);
73 
74  if (sub_num == std::numeric_limits<int>::min())
75  mooseError("The sub-application name '", subapp_full_name, "' must contain a number.");
76 
77  // "remove" CLI args for other sub-applications; remove_if just moves items to the end, so
78  // an erase is needed to actually remove the items
79  auto new_end = std::remove_if(
80  _argv.begin(),
81  _argv.end(),
82  [&sub_name, sub_num](const std::string & arg)
83  {
84  // Determine if the current command line argument ('arg') and extract the sub-application
85  // name and number. If 'arg' is not command line argument for sub-application then the regex
86  // match fails and the argument is retained.
87  std::string arg_sub_name;
88  int arg_sub_num = -1;
89  pcrecpp::RE("(\\S*?)(\\d*):").PartialMatch(arg, &arg_sub_name, &arg_sub_num);
90  if (!arg_sub_name.empty())
91  {
92  // The argument should be retained if names match and the current argument doesn't have
93  // a number or the supplied sub-application number and the current argument number match
94  bool keep = (sub_name == arg_sub_name && (arg_sub_num == -1 || arg_sub_num == sub_num));
95  return !keep;
96  }
97  return false;
98  });
99  _argv.erase(new_end, _argv.end());
100 
101  // If there is an argument meant for a nested subapp, we will want to remove
102  // the leading app name
103  for (auto & arg : _argv)
104  {
105  auto pos = arg.find(":", 0);
106  if (pos != std::string::npos && arg.find(":", pos + 1) != std::string::npos)
107  arg = subapp_full_name + "_" + arg.substr(pos + 1, arg.length() - pos - 1);
108  }
109 
110  // Clear hit CLI arguments, these will be populated after the sub-application is created
111  _hiti.clear();
112  _used_hiti.clear();
113 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::set< int > _hiti
indices of CLI args that are HIT syntax parameters
Definition: CommandLine.h:163
std::vector< std::string > _argv
Storage for the raw argv.
Definition: CommandLine.h:166
std::set< int > _used_hiti
indices of CLI args that have been marked as used
Definition: CommandLine.h:160
auto min(const L &left, const R &right)

◆ markHitParam()

void CommandLine::markHitParam ( int  argi)
inline

Definition at line 123 of file CommandLine.h.

123 { _hiti.insert(argi); }
std::set< int > _hiti
indices of CLI args that are HIT syntax parameters
Definition: CommandLine.h:163

◆ markHitParamUsed()

void CommandLine::markHitParamUsed ( int  argi)
inline

Definition at line 122 of file CommandLine.h.

122 { _used_hiti.insert(argi); };
std::set< int > _used_hiti
indices of CLI args that have been marked as used
Definition: CommandLine.h:160

◆ populateInputParams()

void CommandLine::populateInputParams ( InputParameters params)

Definition at line 134 of file CommandLine.C.

135 {
136 #define trySetParameter(type) \
137  if (dynamic_cast<const libMesh::Parameters::Parameter<type> *>(value.get())) \
138  { \
139  search(name, params.set<type>(name)); \
140  continue; \
141  }
142 
143  for (const auto & [name, value] : params)
144  {
145  if (params.isCommandLineParameter(name) && search(name))
146  {
147  trySetParameter(std::string);
148  trySetParameter(std::vector<std::string>);
149  trySetParameter(Real);
150  trySetParameter(unsigned int);
151  trySetParameter(int);
152  trySetParameter(bool);
153  trySetParameter(MooseEnum);
154 #undef trySetParameter
155 
156  mooseError("Command-line parameter '",
157  name,
158  "' of type '",
159  value->type(),
160  "' is not of a consumable type.\n\nAdd an entry with this type to "
161  "CommandLine::populateInputParams if it is needed.");
162  }
163  else if (params.isParamRequired(name))
164  mooseError("Missing required command-line parameter: ",
165  name,
166  "\nDoc String: ",
167  params.getDocString(name));
168  }
169 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:31
bool search(const std::string &option_name)
This routine searches the command line for the given option "handle" and returns a boolean indicating...
Definition: CommandLine.C:212

◆ printUsage()

void CommandLine::printUsage ( ) const

Print the usage info for this command line.

Definition at line 251 of file CommandLine.C.

Referenced by search().

252 {
253  Moose::out << "Usage: " << getExecutableName() << " [<options>]\n\n"
254  << "Options:\n"
255  << std::left;
256 
257  for (const auto & i : _cli_options)
258  {
259  if (i.second.cli_syntax.empty())
260  continue;
261 
262  std::stringstream oss;
263  for (unsigned int j = 0; j < i.second.cli_syntax.size(); ++j)
264  {
265  if (j)
266  oss << " ";
267  oss << i.second.cli_syntax[j];
268  }
269  Moose::out << " " << std::setw(50) << oss.str() << i.second.description << "\n";
270  }
271 
272  Moose::out << "\nSolver Options:\n"
273  << " See solver manual for details (Petsc or Trilinos)" << std::endl;
274 }
std::map< std::string, Option > _cli_options
Command line options.
Definition: CommandLine.h:156
std::string getExecutableName() const
Get the executable name.
Definition: CommandLine.C:233

◆ search() [1/3]

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 212 of file CommandLine.C.

Referenced by populateInputParams().

213 {
214  auto pos = _cli_options.find(option_name);
215  if (pos != _cli_options.end())
216  {
217  for (const auto & search_string : pos->second.cli_switch)
218  for (auto & arg : _args)
219  if (arg == search_string)
220  return true;
221 
222  if (pos->second.required)
223  {
224  printUsage();
225  mooseError("Required parameter: ", option_name, " missing");
226  }
227  return false;
228  }
229  mooseError("Unrecognized option name: ", option_name);
230 }
std::map< std::string, Option > _cli_options
Command line options.
Definition: CommandLine.h:156
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
void printUsage() const
Print the usage info for this command line.
Definition: CommandLine.C:251
std::vector< std::string > _args
Definition: CommandLine.h:168

◆ search() [2/3]

template<typename T >
bool CommandLine::search ( const std::string &  option_name,
T &  argument 
)

Definition at line 215 of file CommandLine.h.

216 {
217  if (auto pos = _cli_options.find(option_name); pos != _cli_options.end())
218  {
219  const auto & option = pos->second;
220  for (const auto & cli_switch : option.cli_switch)
221  for (const auto arg_i : index_range(_args))
222  {
223  const auto & arg = _args[arg_i];
224 
225  if (arg == cli_switch)
226  {
227  // "Flag" CLI options are added as Boolean types, when we see them
228  // we set the Boolean argument to true
229  if (option.argument_type == ArgumentType::NONE)
230  argument = true;
231  else if (arg_i + 1 < _args.size())
232  {
233  std::stringstream ss;
234  ss << _args[arg_i + 1];
235 
236  setArgument(ss, argument, cli_switch);
237  }
238  else if (option.argument_type == ArgumentType::REQUIRED)
239  {
240  mooseError("The command line argument '",
241  cli_switch,
242  "' requires a value and one was not provided.");
243  }
244  return true;
245  }
246  }
247 
248  if (pos->second.required)
249  {
250  Moose::err << "Required parameter: " << option_name << " missing\n";
251  printUsage();
252  }
253  return false;
254  }
255  mooseError("Unrecognized option name");
256 }
std::map< std::string, Option > _cli_options
Command line options.
Definition: CommandLine.h:156
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
void printUsage() const
Print the usage info for this command line.
Definition: CommandLine.C:251
void setArgument(std::stringstream &stream, T &argument)
Helper for setting the argument value, allows specialization.
Definition: CommandLine.h:173
std::vector< std::string > _args
Definition: CommandLine.h:168
auto index_range(const T &sizable)

◆ search() [3/3]

template<typename T >
bool CommandLine::search ( const std::string &  option_name,
std::vector< T > &  argument 
)

Definition at line 260 of file CommandLine.h.

261 {
262  std::map<std::string, Option>::iterator pos = _cli_options.find(option_name);
263  if (pos != _cli_options.end())
264  {
265  for (unsigned int i = 0; i < pos->second.cli_switch.size(); ++i)
266  {
267  for (size_t j = 0; j < _argv.size(); j++)
268  {
269  auto arg = _argv[j];
270 
271  if (arg == pos->second.cli_switch[i])
272  {
273  // "Flag" CLI options added vector of Boolean types may apprear multiple times on the
274  // command line (like a repeated verbosity flag to increase verbosity), when we see them
275  // we append a true value to the vector.
276  if (pos->second.argument_type == ArgumentType::NONE)
277  argument.push_back(T());
278  else if (pos->second.argument_type == ArgumentType::REQUIRED)
279  mooseError("Adding vector command line parameters with required arguments is not "
280  "currently supported");
281  else
282  while (j + 1 < _argv.size() && _argv[j + 1][0] != '-' &&
283  _argv[j + 1].find("=") == std::string::npos)
284  {
285  std::stringstream ss;
286  ss << _argv[j + 1];
287 
288  T item;
289  setArgument(ss, item, pos->second.cli_switch[i]);
290  argument.push_back(item);
291  ++j;
292  }
293  }
294  }
295  }
296 
297  if (pos->second.required && argument.empty())
298  {
299  Moose::err << "Required parameter: " << option_name << " missing\n";
300  printUsage();
301  }
302  return false;
303  }
304  mooseError("Unrecognized option name");
305 }
std::map< std::string, Option > _cli_options
Command line options.
Definition: CommandLine.h:156
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
void printUsage() const
Print the usage info for this command line.
Definition: CommandLine.C:251
std::vector< std::string > _argv
Storage for the raw argv.
Definition: CommandLine.h:166
void setArgument(std::stringstream &stream, T &argument)
Helper for setting the argument value, allows specialization.
Definition: CommandLine.h:173

◆ setArgument() [1/4]

template<typename T >
void CommandLine::setArgument ( std::stringstream &  stream,
T &  argument 
)
protected

Helper for setting the argument value, allows specialization.

Definition at line 173 of file CommandLine.h.

Referenced by search(), and setArgument().

174 {
175  stream >> argument;
176 }

◆ setArgument() [2/4]

template<typename T >
void CommandLine::setArgument ( std::stringstream &  stream,
T &  argument,
const std::string &  cli_switch 
)
protected

Helper for setting the argument value; catches errors so we can provide more context.

Definition at line 180 of file CommandLine.h.

181 {
182  // Keep track of and change the throw on error characteristics so that
183  // we can catch parsing errors for the argument
184  const auto throw_on_error_orig = Moose::_throw_on_error;
185  Moose::_throw_on_error = true;
186 
187  const auto raw_value = stream.str();
188  try
189  {
190  setArgument(stream, argument);
191  }
192  catch (std::exception & e)
193  {
194  Moose::_throw_on_error = throw_on_error_orig;
195  mooseError("While parsing command line argument '",
196  cli_switch,
197  "' with value '",
198  raw_value,
199  "':\n\n",
200  e.what());
201  }
202 
203  Moose::_throw_on_error = throw_on_error_orig;
204 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
auto raw_value(const Eigen::Map< T > &in)
Definition: ADReal.h:73
void setArgument(std::stringstream &stream, T &argument)
Helper for setting the argument value, allows specialization.
Definition: CommandLine.h:173
bool _throw_on_error
Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or wh...
Definition: Moose.C:639

◆ setArgument() [3/4]

template<>
void CommandLine::setArgument ( std::stringstream &  stream,
MooseEnum argument 
)
protected

◆ setArgument() [4/4]

template<>
void CommandLine::setArgument ( std::stringstream &  stream,
MooseEnum argument 
)
protected

Definition at line 285 of file CommandLine.C.

286 {
287  argument = stream.str();
288 }

◆ unused()

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

Definition at line 128 of file CommandLine.h.

129  {
130  comm.set_union(_hiti);
131  comm.set_union(_used_hiti);
132 
133  std::set<int> unused;
134  for (int i : _hiti)
135  {
136  if (_used_hiti.count(i) == 0)
137  unused.insert(i);
138  }
139  return unused;
140  }
std::set< int > unused(const Parallel::Communicator &comm)
Definition: CommandLine.h:128
std::set< int > _hiti
indices of CLI args that are HIT syntax parameters
Definition: CommandLine.h:163
std::set< int > _used_hiti
indices of CLI args that have been marked as used
Definition: CommandLine.h:160

Member Data Documentation

◆ _args

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

Definition at line 168 of file CommandLine.h.

Referenced by addArgument(), begin(), end(), find(), getExecutableName(), and search().

◆ _argv

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

Storage for the raw argv.

Definition at line 166 of file CommandLine.h.

Referenced by addArgument(), getArguments(), initForMultiApp(), and search().

◆ _cli_options

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

Command line options.

Definition at line 156 of file CommandLine.h.

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

◆ _hiti

std::set<int> CommandLine::_hiti
private

indices of CLI args that are HIT syntax parameters

Definition at line 163 of file CommandLine.h.

Referenced by initForMultiApp(), markHitParam(), and unused().

◆ _used_hiti

std::set<int> CommandLine::_used_hiti
private

indices of CLI args that have been marked as used

Definition at line 160 of file CommandLine.h.

Referenced by initForMultiApp(), markHitParamUsed(), and unused().


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