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...
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...
std::unique_ptr< MooseApp >	create (const std::string &app_type, const std::string &name, InputParameters parameters, MPI_Comm COMM_WORLD_IN)
	Create a MooseApp given a set of parameters. More...
std::shared_ptr< MooseApp >	createShared (const std::string &app_type, const std::string &name, InputParameters parameters, MPI_Comm COMM_WORLD_IN)
	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 std::unique_ptr< MooseApp >	create (const std::string &app_type, const std::vector< std::string > &cli_args={})
	Create an app with no input and command line arguments. More...
static std::unique_ptr< MooseApp >	create (std::unique_ptr< Parser > parser, std::unique_ptr< CommandLine > command_line)
	Create a MooseApp from a Parser and CommandLine, both of which should have parsed. More...
static std::shared_ptr< MooseApp >	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...

Static Public Attributes
static const std::string	main_app_name = "main"
	The name for the "main" moose application. More...

Protected Attributes
AppFactoryBuildInfoMap	_name_to_build_info

Private Member Functions
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...
	AppFactory ()
	Private constructor for singleton pattern. More...
	FRIEND_TEST (::AppFactoryTest, manageAppParams)
	FRIEND_TEST (::AppFactoryTest, appCopyConstructParams)
	FRIEND_TEST (::AppFactoryTest, createNotRegistered)

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 55 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

Private constructor for singleton pattern.

Definition at line 218 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 51 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");
}

create() [1/3]

std::unique_ptr< MooseApp > AppFactory::create ( const std::string &  app_type, const std::vector< std::string > &  cli_args = {}  )

static

Create an app with no input and command line arguments.

Useful for unit testing.

Definition at line 62 of file AppFactory.C.

Referenced by create(), MultiApp::createApp(), createAppShared(), Moose::createMooseApp(), createShared(), and MooseServer::parseDocumentForDiagnostics().

{
  auto parser = std::make_unique<Parser>(std::vector<std::string>());
  parser->parse();
  parser->setAppType(app_type);

  auto command_line = std::make_unique<CommandLine>(std::vector<std::string>{"unused"});
  command_line->addArguments(cli_args);
  command_line->parse();

  return AppFactory::create(std::move(parser), std::move(command_line));
}

create() [2/3]

std::unique_ptr< MooseApp > AppFactory::create ( std::unique_ptr< Parser >  parser, std::unique_ptr< CommandLine >  command_line  )

static

Create a MooseApp from a Parser and CommandLine, both of which should have parsed.

Definition at line 77 of file AppFactory.C.

{
  mooseAssert(parser, "Not set");
  mooseAssert(parser->getAppType().size(), "App type not set");
  mooseAssert(parser->queryRoot(), "Has not parsed");
  mooseAssert(command_line, "Not set");
  mooseAssert(command_line->hasParsed(), "Has not parsed");

  const std::string app_type = parser->getAppType();

  auto app_params = AppFactory::instance().getValidParams(parser->getAppType());
  app_params.set<std::shared_ptr<Parser>>("_parser") = std::move(parser);
  app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(command_line);

  return AppFactory::instance().create(app_type, main_app_name, app_params, MPI_COMM_WORLD);
}

create() [3/3]

std::unique_ptr< MooseApp > AppFactory::create	(	const std::string &	app_type,
		const std::string &	name,
		InputParameters	parameters,
		MPI_Comm	COMM_WORLD_IN
	)

Create a MooseApp given a set of parameters.

The Parser must be set in the _parser param and the CommandLine must be set in the _command_line param, both of which must have been parsed.

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 138 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::Create(): Application '" + app_type + "' was not registered");
  auto & build_info = it->second;

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

  // Take the app_type and add it to the parameters so that it can be retrieved in the Application
  parameters.set<std::string>(MooseBase::type_param) = app_type;
  parameters.set<std::string>(MooseBase::name_param) = name;
  parameters.set<std::string>(MooseBase::unique_name_param) = "Application/" + name;
  parameters.set<std::shared_ptr<Parallel::Communicator>>("_comm") = comm;
  parameters.set<std::string>("_app_name") = name;

  auto parser = parameters.get<std::shared_ptr<Parser>>("_parser");
  mooseAssert(parser, "Parser not valid");
  mooseAssert(parser->queryRoot() && parser->queryCommandLineRoot(), "Parser has not parsed");

  auto command_line = parameters.get<std::shared_ptr<CommandLine>>("_command_line");
  mooseAssert(command_line, "Command line not valid");
  mooseAssert(command_line->hasParsed(), "Command line has not 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);
}

createAppShared()

std::shared_ptr< MooseApp > 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 95 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()'. ");

  // Populate the -i and --app parameters early
  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");
  std::string app_type = command_line_params.get<std::string>("app_to_run");

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

  auto parser = std::make_unique<Parser>(input_filenames);
  parser->setCommandLineParams(command_line->buildHitParams());
  parser->parse();

  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<std::shared_ptr<Parser>>("_parser") = std::move(parser);
  app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(command_line);

  return AppFactory::instance().create(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 189 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()

std::shared_ptr< MooseApp > AppFactory::createShared	(	const std::string &	app_type,
		const std::string &	name,
		InputParameters	parameters,
		MPI_Comm	COMM_WORLD_IN
	)

Definition at line 180 of file AppFactory.C.

{
  return AppFactory::instance().create(app_type, name, parameters, comm_world_in);
}

FRIEND_TEST() [1/3]

AppFactory::FRIEND_TEST ( ::AppFactoryTest  , manageAppParams    )

private

FRIEND_TEST() [2/3]

AppFactory::FRIEND_TEST ( ::AppFactoryTest  , appCopyConstructParams    )

private

FRIEND_TEST() [3/3]

AppFactory::FRIEND_TEST ( ::AppFactoryTest  , createNotRegistered    )

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 42 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 214 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 33 of file AppFactory.C.

Referenced by create(), 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(), create(), MultiApp::createApp(), MultiApp::createApps(), createAppShared(), Moose::createMooseApp(), createShared(), 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 169 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 232 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 183 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 164 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 200 of file AppFactory.C.

Referenced by create().

{
  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 227 of file AppFactory.h.

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

_name_to_build_info

AppFactoryBuildInfoMap AppFactory::_name_to_build_info

protected

Definition at line 194 of file AppFactory.h.

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

main_app_name

const std::string AppFactory::main_app_name = "main"

static

The name for the "main" moose application.

Definition at line 69 of file AppFactory.h.

Referenced by create(), MooseBase::messagePrefix(), and MooseServer::parseDocumentForDiagnostics().

---

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

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