ActionFactory Class Reference

Specialized factory for generic Action System objects. More...

#include <ActionFactory.h>

Classes
struct	BuildInfo

Public Types
typedef std::multimap< std::string, BuildInfo >::iterator	iterator
	Typedef for registered Action iterator.
typedef std::multimap< std::string, BuildInfo >::const_iterator	const_iterator

Public Member Functions
	ActionFactory (MooseApp &app)
virtual	~ActionFactory ()
MooseApp &	app ()
void	reg (std::shared_ptr< RegistryEntryBase > obj)
FileLineInfo	getLineInfo (const std::string &name, const std::string &task) const
	Gets file and line information where an action was registered.
std::string	getTaskName (const std::string &action)
std::shared_ptr< Action >	create (const std::string &action, const std::string &action_name, InputParameters &parameters)
InputParameters	getValidParams (const std::string &name)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
std::pair< std::multimap< std::string, std::string >::const_iterator, std::multimap< std::string, std::string >::const_iterator >	getActionsByTask (const std::string &task) const
	Returns begin and end iterators in a multimap from tasks to actions names.
std::set< std::string >	getTasksByAction (const std::string &action) const
bool	isRegisteredTask (const std::string &task) const
	Whether or not a task with the name task is registered.
const InputParameters *	currentlyConstructing () const

Static Private Member Functions
template<class T >
static std::shared_ptr< Action >	buildAction (const InputParameters &parameters)

Private Attributes
MooseApp &	_app
std::multimap< std::string, BuildInfo >	_name_to_build_info
FileLineInfoMap	_name_to_line
std::multimap< std::string, std::string >	_task_to_action_map
std::set< std::pair< std::string, std::string > >	_current_objs
	set<objectname, task> used to track if an object previously added is being added again
std::set< std::string >	_tasks
	The registered tasks.
std::vector< const InputParameters * >	_currently_constructing
	The object's parameters that are currently being constructed (if any).

Detailed Description

Specialized factory for generic Action System objects.

Definition at line 48 of file ActionFactory.h.

Member Typedef Documentation

const_iterator

typedef std::multimap<std::string,BuildInfo>::const_iterator ActionFactory::const_iterator

Definition at line 82 of file ActionFactory.h.

iterator

typedef std::multimap<std::string,BuildInfo>::iterator ActionFactory::iterator

Typedef for registered Action iterator.

Definition at line 81 of file ActionFactory.h.

Constructor & Destructor Documentation

ActionFactory()

ActionFactory::ActionFactory

(

MooseApp &

app

)

Definition at line 17 of file ActionFactory.C.

: _app(app) {}

~ActionFactory()

ActionFactory::~ActionFactory ( )

virtual

Definition at line 19 of file ActionFactory.C.

{}

Member Function Documentation

app()

MooseApp & ActionFactory::app ( )

inline

Definition at line 55 of file ActionFactory.h.

{ return _app; }

begin() [1/2]

ActionFactory::iterator ActionFactory::begin

(

)

Definition at line 126 of file ActionFactory.C.

{
  return _name_to_build_info.begin();
}

begin() [2/2]

ActionFactory::const_iterator ActionFactory::begin

(

)

const

Definition at line 132 of file ActionFactory.C.

{
  return _name_to_build_info.begin();
}

buildAction()

template<class T >

static std::shared_ptr< Action > ActionFactory::buildAction ( const InputParameters &  parameters )

inlinestaticprivate

Definition at line 112 of file ActionFactory.h.

  {
    return std::make_shared<T>(parameters);
  }

create()

std::shared_ptr< Action > ActionFactory::create	(	const std::string &	action,
		const std::string &	action_name,
		InputParameters &	parameters
	)

Definition at line 40 of file ActionFactory.C.

{
  std::string action_name = MooseUtils::shortName(full_action_name);
  incoming_parser_params.addPrivateParam(MooseBase::app_param, &_app);
  incoming_parser_params.set<std::string>(MooseBase::type_param) = action;
 
  std::pair<ActionFactory::iterator, ActionFactory::iterator> iters;
 
  const std::string unique_action_name =
      action + incoming_parser_params.get<std::string>("task") + full_action_name;
 
  // Create the actual parameters object that the object will reference
  InputParameters & action_params = _app.getInputParameterWarehouse().addInputParameters(
      unique_action_name, incoming_parser_params, 0, {});
 
  if (!action_params.getHitNode())
  {
    // If we currently are in an action, that means that we're creating an
    // action from within an action. Associate the action creating this one
    // with the new action's parameters so that errors can be associated with it
    if (const auto hit_node = _app.getCurrentActionHitNode())
      action_params.setHitNode(*hit_node, {});
    // Don't have one, so just use the root
    else
      action_params.setHitNode(_app.parser().getRoot(), {});
  }
 
  action_params.set<std::string>(Action::unique_action_name_param) = unique_action_name;
  action_params.set<std::string>(MooseBase::name_param) = action_name;
 
  // Check and finalize the parameters
  action_params.finalize(action_name);
 
  iters = _name_to_build_info.equal_range(action);
  BuildInfo * build_info = &(iters.first->second);
  if (!build_info)
    mooseError(
        std::string("Unable to find buildable Action from supplied InputParameters Object for ") +
        action_name);
 
  // Create the object
  _currently_constructing.push_back(&action_params);
  std::shared_ptr<Action> action_obj = build_info->_obj_pointer->buildAction(action_params);
  _currently_constructing.pop_back();
 
  if (action_params.get<std::string>("task") == "")
    action_obj->appendTask(build_info->_task);
 
  return action_obj;
}

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionWarehouse::buildBuildableActions(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), MooseApp::createMinimalApp(), DumpObjectsProblem::DumpObjectsProblem(), CreateExecutionerAction::setupAutoPreconditioning(), ReadExecutorParamsAction::setupAutoPreconditioning(), and Moose::Builder::walkRaw().

currentlyConstructing()

const InputParameters * ActionFactory::currentlyConstructing

(

)

const

Returns

The InputParameters for the object that is currently being constructed, if any.

Can be used to ensure that all Actions are created using the ActionFactory

Definition at line 173 of file ActionFactory.C.

{
  return _currently_constructing.size() ? _currently_constructing.back() : nullptr;
}

Referenced by Action::Action().

end() [1/2]

ActionFactory::iterator ActionFactory::end

(

)

Definition at line 138 of file ActionFactory.C.

{
  return _name_to_build_info.end();
}

end() [2/2]

ActionFactory::const_iterator ActionFactory::end

(

)

const

Definition at line 144 of file ActionFactory.C.

{
  return _name_to_build_info.end();
}

getActionsByTask()

std::pair< std::multimap< std::string, std::string >::const_iterator, std::multimap< std::string, std::string >::const_iterator > ActionFactory::getActionsByTask

(

const std::string &

task

)

const

Returns begin and end iterators in a multimap from tasks to actions names.

Definition at line 151 of file ActionFactory.C.

{
  return _task_to_action_map.equal_range(task);
}

Referenced by ActionWarehouse::buildBuildableActions(), and Moose::Builder::buildJsonSyntaxTree().

getLineInfo()

FileLineInfo ActionFactory::getLineInfo	(	const std::string &	name,
		const std::string &	task
	)		const

Gets file and line information where an action was registered.

Parameters

name	Action name
task	task name

Returns

A FileLineInfo associated with the name/task pair

Definition at line 179 of file ActionFactory.C.

{
  return _name_to_line.getInfo(name, task);
}

Referenced by Moose::Builder::buildJsonSyntaxTree().

getTaskName()

std::string ActionFactory::getTaskName

(

const std::string &

action

)

Definition at line 114 of file ActionFactory.C.

{
  // We are returning only the first found instance here
  std::multimap<std::string, BuildInfo>::iterator iter = _name_to_build_info.find(action);
 
  if (iter != _name_to_build_info.end())
    return iter->second._task;
  else
    return "";
}

Referenced by Moose::Builder::buildFullTree(), and Moose::Builder::buildJsonSyntaxTree().

getTasksByAction()

std::set< std::string > ActionFactory::getTasksByAction

(

const std::string &

action

)

const

Definition at line 157 of file ActionFactory.C.

{
  std::set<std::string> tasks;
 
  std::pair<std::multimap<std::string, ActionFactory::BuildInfo>::const_iterator,
            std::multimap<std::string, ActionFactory::BuildInfo>::const_iterator>
      iters = _name_to_build_info.equal_range(action);
  for (std::multimap<std::string, ActionFactory::BuildInfo>::const_iterator it = iters.first;
       it != iters.second;
       ++it)
    tasks.insert(it->second._task);
 
  return tasks;
}

Referenced by ActionWarehouse::addActionBlock(), Moose::Builder::buildJsonSyntaxTree(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), and MooseServer::getActionParameters().

getValidParams()

InputParameters ActionFactory::getValidParams

(

const std::string &

name

)

If an Action is registered more than once, it'll appear in the _name_to_build_info data structure multiple times. The actual parameters function remains the same however so we can safely use the first instance

Definition at line 94 of file ActionFactory.C.

{
  ActionFactory::iterator iter = _name_to_build_info.find(name);
 
  if (iter == _name_to_build_info.end())
    mooseError(std::string("A '") + name + "' is not a registered Action\n\n");
 
  InputParameters params = iter->second._obj_pointer->buildParameters();
  params.addPrivateParam(MooseBase::app_param, &_app);
  params.addPrivateParam<ActionWarehouse *>("awh", &_app.actionWarehouse());
 
  return params;
}

Referenced by CreateMeshSetupActionsForComponents::act(), ActionWarehouse::buildBuildableActions(), Moose::Builder::buildFullTree(), Moose::Builder::buildJsonSyntaxTree(), AddVariableAction::createInitialConditionAction(), MooseApp::createMinimalApp(), DumpObjectsProblem::DumpObjectsProblem(), MooseServer::getActionParameters(), Moose::Builder::listValidParams(), CreateExecutionerAction::setupAutoPreconditioning(), ReadExecutorParamsAction::setupAutoPreconditioning(), and Moose::Builder::walkRaw().

isRegisteredTask()

bool ActionFactory::isRegisteredTask ( const std::string &  task ) const

inline

Whether or not a task with the name task is registered.

Definition at line 100 of file ActionFactory.h.

{ return _tasks.count(task); }

Referenced by ActionWarehouse::hasTask().

reg()

void ActionFactory::reg

(

std::shared_ptr< RegistryEntryBase >

obj

)

Definition at line 22 of file ActionFactory.C.

{
  const std::string & name = obj->_classname;
  const std::string & task = obj->_name;
 
  auto key = std::make_pair(name, task);
  if (_current_objs.count(key) > 0)
    return;
  _current_objs.insert(key);
 
  BuildInfo build_info{obj, task};
  _name_to_build_info.insert(std::make_pair(name, build_info));
  _task_to_action_map.insert(std::make_pair(task, name));
  _tasks.insert(task);
  _name_to_line.addInfo(name, task, obj->_file, obj->_line);
}

Referenced by Registry::registerActionsTo().

Member Data Documentation

_app

MooseApp& ActionFactory::_app

private

Definition at line 117 of file ActionFactory.h.

Referenced by app(), create(), and getValidParams().

_current_objs

std::set<std::pair<std::string, std::string> > ActionFactory::_current_objs

private

set<objectname, task> used to track if an object previously added is being added again

Definition at line 125 of file ActionFactory.h.

Referenced by reg().

_currently_constructing

std::vector<const InputParameters *> ActionFactory::_currently_constructing

private

The object's parameters that are currently being constructed (if any).

This is a vector because we create within create, thus the last entry is the one that is being constructed at the moment

Definition at line 133 of file ActionFactory.h.

Referenced by currentlyConstructing().

_name_to_build_info

std::multimap<std::string, BuildInfo> ActionFactory::_name_to_build_info

private

Definition at line 119 of file ActionFactory.h.

Referenced by begin(), begin(), end(), end(), getTaskName(), getTasksByAction(), getValidParams(), and reg().

_name_to_line

FileLineInfoMap ActionFactory::_name_to_line

private

Definition at line 121 of file ActionFactory.h.

Referenced by getLineInfo(), and reg().

_task_to_action_map

std::multimap<std::string, std::string> ActionFactory::_task_to_action_map

private

Definition at line 122 of file ActionFactory.h.

Referenced by getActionsByTask(), and reg().

_tasks

std::set<std::string> ActionFactory::_tasks

private

The registered tasks.

Definition at line 128 of file ActionFactory.h.

Referenced by isRegisteredTask(), and reg().

---

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

• include/actions/ActionFactory.h
• src/actions/ActionFactory.C