AppFactory Class Reference

Generic AppFactory class for building Application objects. More...

#include <AppFactory.h>

Classes
class	ClearAppParamsKey
	Class that is used as a parameter to clearAppParams() that allows only MooseApp to call clearAppParams(). More...

Public Member Functions
virtual	~AppFactory ()
template<typename T >
void	reg (const std::string &name)
	Register a new object. More...
InputParameters	getValidParams (const std::string &name)
	Get valid parameters for the object. More...
const InputParameters &	getAppParams (const InputParameters &params) const
void	clearAppParams (const InputParameters &params, const ClearAppParamsKey)
	Clears the stored parameters for the given application parameteres. More...
MooseAppPtr	createShared (const std::string &app_type, const std::string &name, InputParameters parameters, MPI_Comm COMM_WORLD_IN)
	Build an application object (must be registered) More...
const auto &	registeredObjects () const
	Returns a reference to the map from names to AppFactoryBuildInfo pointers. More...
bool	isRegistered (const std::string &app_name) const
	Returns a Boolean indicating whether an application type has been registered. More...
std::size_t	createdAppCount (const std::string &app_type) const
const AppFactoryBuildInfoMap &	registeredObjectBuildInfos () const
	Returns the map of object name to a function pointer for building said object's input parameters. More...
	AppFactory (AppFactory const &)=delete
	Don't allow creation through copy/move construction or assignment. More...
Registry &	operator= (AppFactory const &)=delete
	AppFactory (AppFactory &&)=delete
Registry &	operator= (AppFactory &&)=delete

Static Public Member Functions
static AppFactory &	instance ()
	Get the instance of the AppFactory. More...
static InputParameters	validParams ()
static MooseAppPtr	createAppShared (int argc, char **argv, std::unique_ptr< Parser > parser)
	Helper function for creating a MooseApp from command-line arguments and a Parser. More...
static MooseAppPtr	createAppShared (const std::string &default_app_type, int argc, char **argv, MPI_Comm comm_word=MPI_COMM_WORLD)
	Deprecated helper function for creating a MooseApp for Apps haven't adapted to the new Parser and Builder changes. More...

Protected Attributes
AppFactoryBuildInfoMap	_name_to_build_info

Private Member Functions
	AppFactory ()
const InputParameters &	storeAppParams (InputParameters &params)
	Stores the given parameters within _input_parameters for app construction. More...
std::size_t	getAppParamsID (const InputParameters &params) const
	Get the ID for the InputParameters associated with an application, used in storing them in _input_parameters. More...
	FRIEND_TEST (::AppFactoryTest, manageAppParams)
	FRIEND_TEST (::AppFactoryTest, appCopyConstructParams)

Private Attributes
std::map< std::size_t, std::unique_ptr< InputParameters > >	_input_parameters
	Storage of input parameters used in applications (ID (from getAppParamsID()) -> params) More...

Detailed Description

Generic AppFactory class for building Application objects.

Definition at line 62 of file AppFactory.h.

Constructor & Destructor Documentation

~AppFactory()

AppFactory::~AppFactory ( )

virtual

Definition at line 28 of file AppFactory.C.

{}

AppFactory() [1/3]

AppFactory::AppFactory ( AppFactory const &  )

delete

Don't allow creation through copy/move construction or assignment.

AppFactory() [2/3]

AppFactory::AppFactory ( AppFactory &&  )

delete

AppFactory() [3/3]

AppFactory::AppFactory ( )

inlineprivate

Definition at line 184 of file AppFactory.h.

Referenced by instance().

{}

Member Function Documentation

clearAppParams()

void AppFactory::clearAppParams	(	const InputParameters &	params,
		const ClearAppParamsKey
	)

Clears the stored parameters for the given application parameteres.

See getAppParams() for why this is needed.

Definition at line 49 of file AppFactory.C.

Referenced by MooseApp::~MooseApp().

{
  const auto id = getAppParamsID(params);
  if (const auto it = _input_parameters.find(id); it != _input_parameters.end())
    _input_parameters.erase(it);
  else
    mooseError(
        "AppFactory::clearAppParams(): Parameters for application with ID ", id, " not found");
}

createAppShared() [1/2]

MooseAppPtr AppFactory::createAppShared ( int  argc, char **  argv, std::unique_ptr< Parser >  parser  )

static

Helper function for creating a MooseApp from command-line arguments and a Parser.

The parser must be set and have an app type set.

Definition at line 60 of file AppFactory.C.

Referenced by Moose::createMooseApp().

{
  mooseAssert(parser, "Not set");
  mooseAssert(parser->getAppType().size(), "App type not set");
  const std::string app_type = parser->getAppType();

  auto command_line = std::make_unique<CommandLine>(argc, argv);
  command_line->parse();

  auto app_params = AppFactory::instance().getValidParams(parser->getAppType());
  app_params.set<int>("_argc") = argc;
  app_params.set<char **>("_argv") = argv;
  app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(command_line);
  app_params.set<std::shared_ptr<Parser>>("_parser") = std::move(parser);

  return AppFactory::instance().createShared(app_type, "main", app_params, MPI_COMM_WORLD);
}

createAppShared() [2/2]

MooseAppPtr AppFactory::createAppShared ( const std::string &  default_app_type, int  argc, char **  argv, MPI_Comm  comm_word = MPI_COMM_WORLD  )

static

Deprecated helper function for creating a MooseApp for Apps haven't adapted to the new Parser and Builder changes.

This function needed to be removed after the new Parser and Builder merged

Definition at line 79 of file AppFactory.C.

{
  mooseDeprecated("Please update your main.C to adapt new main function in MOOSE framework, "
                  "see'test/src/main.C in MOOSE as an example of moose::main()'. ");

  auto command_line_params = emptyInputParameters();
  MooseApp::addInputParam(command_line_params);
  MooseApp::addAppParam(command_line_params);

  {
    CommandLine pre_command_line(argc, argv);
    pre_command_line.parse();
    pre_command_line.populateCommandLineParams(command_line_params);
  }

  const auto & input_filenames = command_line_params.get<std::vector<std::string>>("input_file");
  auto parser = std::make_unique<Parser>(input_filenames);
  if (input_filenames.size())
    parser->parse();

  std::string app_type = command_line_params.get<std::string>("app_to_run");
  if (app_type.empty())
    app_type = default_app_type;
  else
    mooseDeprecated("Please use [Application] block to specify application type, '--app <AppName>' "
                    "is deprecated and will be removed in a future release.");

  parser->setAppType(app_type);
  auto app_params = AppFactory::instance().getValidParams(app_type);

  app_params.set<int>("_argc") = argc;
  app_params.set<char **>("_argv") = argv;

  auto command_line = std::make_unique<CommandLine>(argc, argv);
  command_line->parse();
  app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(command_line);

  // Take the front parser and add it to the parameters so that it can be retrieved in the
  // Application
  app_params.set<std::shared_ptr<Parser>>("_parser") = std::move(parser);

  return AppFactory::instance().createShared(app_type, "main", app_params, comm_world_in);
}

createdAppCount()

std::size_t AppFactory::createdAppCount

(

const std::string &

app_type

)

const

Returns

the amount of times the AppFactory created the named App-type

Definition at line 168 of file AppFactory.C.

{
  // Error if the application type is not located
  const auto it = _name_to_build_info.find(app_type);
  if (it == _name_to_build_info.end())
    mooseError("AppFactory::createdAppCount(): '", app_type, "' is not a registered app");

  return it->second->_app_creation_count;
}

createShared()

MooseAppPtr AppFactory::createShared	(	const std::string &	app_type,
		const std::string &	name,
		InputParameters	parameters,
		MPI_Comm	COMM_WORLD_IN
	)

Build an application object (must be registered)

Parameters

app_type	Type of the application being constructed
name	Name for the object
parameters	Parameters this object should have

Returns

The created object

Definition at line 127 of file AppFactory.C.

Referenced by MultiApp::createApp(), createAppShared(), and MooseServer::parseDocumentForDiagnostics().

{
  // Error if the application type is not located
  const auto it = _name_to_build_info.find(app_type);
  if (it == _name_to_build_info.end())
    mooseError("Object '" + app_type + "' was not registered.");
  auto & build_info = it->second;

  // Take the app_type and add it to the parameters so that it can be retrieved in the Application
  parameters.set<std::string>("_type") = app_type;

  auto comm = std::make_shared<Parallel::Communicator>(comm_world_in);

  parameters.set<std::shared_ptr<Parallel::Communicator>>("_comm") = comm;
  parameters.set<std::string>("_app_name") = name;

  if (!parameters.isParamValid("_command_line"))
    mooseError("Valid CommandLine object required");

  std::shared_ptr<CommandLine> command_line =
      parameters.get<std::shared_ptr<CommandLine>>("_command_line");
  mooseAssert(command_line->hasParsed(), "Should have been parsed");

  command_line->populateCommandLineParams(parameters);

  // Historically we decided to non-const copy construct all application parameters. In
  // order to get around that while apps are fixed (by taking a const reference instead),
  // we store the app params here and the MooseApp constructor will query the InputParameters
  // owned by ths factory instead of the ones that are passed to it (likely a const ref to a
  // copy of the derived app's parmeters)
  const auto & params = storeAppParams(parameters);

  build_info->_app_creation_count++;

  return build_info->build(params);
}

FRIEND_TEST() [1/2]

AppFactory::FRIEND_TEST ( ::AppFactoryTest  , manageAppParams    )

private

FRIEND_TEST() [2/2]

AppFactory::FRIEND_TEST ( ::AppFactoryTest  , appCopyConstructParams    )

private

getAppParams()

const InputParameters & AppFactory::getAppParams

(

const InputParameters &

params

)

const

Returns

The parameters for the application named name

This is needed because we poorly decided to not pass references of the InputParameters in all derived MooseApp objects. This enables the MooseApp to get the copy of the parameters that it was actually built with using this factory.

Definition at line 40 of file AppFactory.C.

{
  const auto id = getAppParamsID(params);
  if (const auto it = _input_parameters.find(id); it != _input_parameters.end())
    return *it->second;
  mooseError("AppFactory::getAppParams(): Parameters for application with ID ", id, " not found");
}

getAppParamsID()

std::size_t AppFactory::getAppParamsID ( const InputParameters &  params ) const

private

Get the ID for the InputParameters associated with an application, used in storing them in _input_parameters.

This is needed until app constructors do not copy construct parameters. See getAppParams() for more information.

The parameters passed in here (from the app) could be copy-constructed parameters, but will contain a "_app_params_id" parameter that allows us to get the actual parameters (owned by this factory).

Definition at line 193 of file AppFactory.C.

Referenced by clearAppParams(), and getAppParams().

{
  if (!params.have_parameter<std::size_t>("_app_params_id"))
    mooseError("AppFactory::getAppParamsID(): Invalid application parameters (missing "
               "'_app_params_id')");
  return params.get<std::size_t>("_app_params_id");
}

getValidParams()

InputParameters AppFactory::getValidParams

(

const std::string &

name

)

Get valid parameters for the object.

Parameters

name	Name of the object whose parameter we are requesting

Returns

Parameters of the object

Definition at line 31 of file AppFactory.C.

Referenced by MultiApp::createApp(), and createAppShared().

{
  if (const auto it = _name_to_build_info.find(name); it != _name_to_build_info.end())
    return it->second->buildParameters();

  mooseError(std::string("A '") + name + "' is not a registered object\n\n");
}

instance()

AppFactory & AppFactory::instance ( )

static

Get the instance of the AppFactory.

Returns

Reference to the AppFactory instance

Definition at line 18 of file AppFactory.C.

Referenced by JsonSyntaxTree::addGlobal(), MultiApp::createApp(), MultiApp::createApps(), createAppShared(), Moose::createMooseApp(), MooseApp::dynamicAppRegistration(), MooseServer::parseDocumentForDiagnostics(), MultiApp::validParams(), and MooseApp::~MooseApp().

{
  // We need a naked new here (_not_ a smart pointer or object instance) due to what seems like a
  // bug in clang's static object destruction when using dynamic library loading.
  static AppFactory * instance = nullptr;
  if (!instance)
    instance = new AppFactory;
  return *instance;
}

isRegistered()

bool AppFactory::isRegistered ( const std::string &  app_name ) const

inline

Returns a Boolean indicating whether an application type has been registered.

Definition at line 155 of file AppFactory.h.

Referenced by MultiApp::createApp(), and reg().

  {
    return _name_to_build_info.count(app_name);
  }

operator=() [1/2]

Registry& AppFactory::operator= ( AppFactory const &  )

delete

operator=() [2/2]

Registry& AppFactory::operator= ( AppFactory &&  )

delete

reg()

template<typename T >

void AppFactory::reg

(

const std::string &

name

)

Register a new object.

Parameters

name	Name of the object to register

Definition at line 217 of file AppFactory.h.

{
  if (isRegistered(name))
    return;

  _name_to_build_info[name] = std::make_unique<AppFactoryBuildInfo<T>>();
  Moose::Capabilities::getCapabilityRegistry().add(
      name, true, "MOOSE application " + name + " is available.");
}

registeredObjectBuildInfos()

const AppFactoryBuildInfoMap& AppFactory::registeredObjectBuildInfos ( ) const

inline

Returns the map of object name to a function pointer for building said object's input parameters.

Definition at line 169 of file AppFactory.h.

{ return _name_to_build_info; }

registeredObjects()

const auto& AppFactory::registeredObjects ( ) const

inline

Returns a reference to the map from names to AppFactoryBuildInfo pointers.

Definition at line 150 of file AppFactory.h.

Referenced by MultiApp::validParams().

{ return _name_to_build_info; }

storeAppParams()

const InputParameters & AppFactory::storeAppParams ( InputParameters &  params )

private

Stores the given parameters within _input_parameters for app construction.

Also calls finalize() on the parameters.

Definition at line 179 of file AppFactory.C.

Referenced by createShared().

{
  const std::size_t next_id =
      _input_parameters.size() ? (std::prev(_input_parameters.end())->first + 1) : 0;
  params.addPrivateParam<std::size_t>("_app_params_id", next_id);
  const auto it_inserted_pair =
      _input_parameters.emplace(next_id, std::make_unique<InputParameters>(params));
  mooseAssert(it_inserted_pair.second, "Already exists");
  auto & stored_params = *it_inserted_pair.first->second;
  stored_params.finalize("");
  return stored_params;
}

validParams()

static InputParameters AppFactory::validParams ( )

static

Member Data Documentation

_input_parameters

std::map<std::size_t, std::unique_ptr<InputParameters> > AppFactory::_input_parameters

private

Storage of input parameters used in applications (ID (from getAppParamsID()) -> params)

Definition at line 212 of file AppFactory.h.

Referenced by clearAppParams(), getAppParams(), and storeAppParams().

_name_to_build_info

AppFactoryBuildInfoMap AppFactory::_name_to_build_info

protected

Definition at line 180 of file AppFactory.h.

Referenced by createdAppCount(), createShared(), getValidParams(), isRegistered(), reg(), registeredObjectBuildInfos(), and registeredObjects().

---

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

• include/base/AppFactory.h
• src/base/AppFactory.C