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

#include <AppFactory.h>

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

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

bool	isRegistered (const std::string &app_name) const
	Returns a Boolean indicating whether an application type has been registered. More...


registeredMooseAppIterator	registeredObjectsBegin ()
	Returns iterators to the begin/end of the registered objects data structure: a name -> validParams function pointer. More...

registeredMooseAppIterator	registeredObjectsEnd ()

Static Public Member Functions
static AppFactory &	instance ()
	Get the instance of the AppFactory. More...

static MooseAppPtr	createAppShared (const std::string &app_type, int argc, char **argv, MPI_Comm comm_word=MPI_COMM_WORLD)
	Helper function for creating a MooseApp from command-line arguments. More...

Protected Attributes
std::map< std::string, appBuildPtr >	_name_to_build_pointer

std::map< std::string, paramsPtr >	_name_to_params_pointer

Static Protected Attributes
static AppFactory	_instance = AppFactory()

Private Member Functions
	AppFactory ()

Detailed Description

Generic AppFactory class for building Application objects.

Definition at line 58 of file AppFactory.h.

Constructor & Destructor Documentation

◆ ~AppFactory()

AppFactory::~AppFactory ( )

virtual

Definition at line 22 of file AppFactory.C.

22 {}

◆ AppFactory()

AppFactory::AppFactory ( )

inlineprivate

Definition at line 133 of file AppFactory.h.

133 {}

Member Function Documentation

◆ createAppShared()

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

static

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

Definition at line 35 of file AppFactory.C.

 {
   auto command_line = std::make_shared<CommandLine>(argc, argv);
   auto app_params = AppFactory::instance().getValidParams(app_type);
 
   app_params.set<int>("_argc") = argc;
   app_params.set<char **>("_argv") = argv;
   app_params.set<std::shared_ptr<CommandLine>>("_command_line") = command_line;
 
   return AppFactory::instance().createShared(app_type, "main", app_params, comm_world_in);
 }

◆ 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 51 of file AppFactory.C.

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

 {
   // Error if the application type is not located
   if (_name_to_build_pointer.find(app_type) == _name_to_build_pointer.end())
     mooseError("Object '" + app_type + "' was not registered.");
 
   // 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;
 
   // Check to make sure that all required parameters are supplied
   parameters.checkParams("");
 
   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");
   command_line->addCommandLineOptionsFromParams(parameters);
   command_line->populateInputParams(parameters);
 
   return (*_name_to_build_pointer[app_type])(parameters);
 }

◆ 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 25 of file AppFactory.C.

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

 {
   if (_name_to_params_pointer.find(name) == _name_to_params_pointer.end())
     mooseError(std::string("A '") + name + "' is not a registered object\n\n");
 
   InputParameters params = _name_to_params_pointer[name]();
   return params;
 }

◆ instance()

AppFactory & AppFactory::instance ( )

static

Get the instance of the AppFactory.

Returns: Pointer to the AppFactory instance

Definition at line 17 of file AppFactory.C.

Referenced by JsonSyntaxTree::addGlobal(), MultiApp::createApp(), createAppShared(), MooseApp::dynamicAppRegistration(), MultiApp::initialSetup(), and validParams< MultiApp >().

 {
   return _instance;
 }

◆ isRegistered()

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

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

Definition at line 83 of file AppFactory.C.

 {
   return _name_to_params_pointer.find(app_name) != _name_to_params_pointer.end();
 }

◆ reg()

template<typename T >

void AppFactory::reg ( const std::string & name )

inline

Register a new object.

Parameters

name	Name of the object to register

Definition at line 82 of file AppFactory.h.

   {
     if (_name_to_build_pointer.find(name) == _name_to_build_pointer.end())
     {
       _name_to_build_pointer[name] = &buildApp<T>;
       _name_to_params_pointer[name] = &validParams<T>;
     }
   }