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. More...
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. More...
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
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. More...
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 More...
std::set< std::string >	_tasks
	The registered tasks. More...
std::vector< const InputParameters * >	_currently_constructing
	The object's parameters that are currently being constructed (if any). More...

Detailed Description

Specialized factory for generic Action System objects.

Definition at line 50 of file ActionFactory.h.

Member Typedef Documentation

const_iterator

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

Definition at line 84 of file ActionFactory.h.

iterator

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

Typedef for registered Action iterator.

Definition at line 83 of file ActionFactory.h.

Constructor & Destructor Documentation

ActionFactory()

ActionFactory::ActionFactory

(

MooseApp &

app

)

Definition at line 16 of file ActionFactory.C.

: _app(app) {}

~ActionFactory()

ActionFactory::~ActionFactory ( )

virtual

Definition at line 18 of file ActionFactory.C.

{}

Member Function Documentation

app()

MooseApp& ActionFactory::app ( )

inline

Definition at line 57 of file ActionFactory.h.

{ return _app; }

begin() [1/2]

ActionFactory::iterator ActionFactory::begin

(

)

Definition at line 124 of file ActionFactory.C.

{
  return _name_to_build_info.begin();
}

begin() [2/2]

ActionFactory::const_iterator ActionFactory::begin

(

)

const

Definition at line 130 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 113 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 39 of file ActionFactory.C.

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

{
  std::string action_name = MooseUtils::shortName(full_action_name);
  incoming_parser_params.addPrivateParam("_moose_app", &_app);
  incoming_parser_params.addPrivateParam("action_type", action);
  std::pair<ActionFactory::iterator, ActionFactory::iterator> iters;

  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().root(), {});
  }

  // 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);

  // Add the name to the parameters
  action_params.set<std::string>("_action_name") = action_name;
  action_params.set<std::string>("_unique_action_name") = unique_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;
}

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 171 of file ActionFactory.C.

Referenced by Action::Action().

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

end() [1/2]

ActionFactory::iterator ActionFactory::end

(

)

Definition at line 136 of file ActionFactory.C.

{
  return _name_to_build_info.end();
}

end() [2/2]

ActionFactory::const_iterator ActionFactory::end

(

)

const

Definition at line 142 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

Definition at line 149 of file ActionFactory.C.

Referenced by ActionWarehouse::buildBuildableActions().

{
  return _task_to_action_map.equal_range(task);
}

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 177 of file ActionFactory.C.

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

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

getTaskName()

std::string ActionFactory::getTaskName

(

const std::string &

action

)

Definition at line 112 of file ActionFactory.C.

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

{
  // 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 "";
}

getTasksByAction()

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

(

const std::string &

action

)

const

Definition at line 155 of file ActionFactory.C.

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

{
  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;
}

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 92 of file ActionFactory.C.

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

{
  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("_moose_app", &_app);
  params.addPrivateParam<ActionWarehouse *>("awh", &_app.actionWarehouse());

  return params;
}

isRegisteredTask()

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

inline

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

Definition at line 101 of file ActionFactory.h.

Referenced by ActionWarehouse::hasTask().

{ return _tasks.count(task); }

reg()

void ActionFactory::reg

(

std::shared_ptr< RegistryEntryBase >

obj

)

Definition at line 21 of file ActionFactory.C.

Referenced by Registry::registerActionsTo().

{
  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);
}

Member Data Documentation

_app

MooseApp& ActionFactory::_app

private

Definition at line 118 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 126 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 134 of file ActionFactory.h.

Referenced by create(), and currentlyConstructing().

_name_to_build_info

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

private

Definition at line 120 of file ActionFactory.h.

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

_name_to_line

FileLineInfoMap ActionFactory::_name_to_line

private

Definition at line 122 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 123 of file ActionFactory.h.

Referenced by getActionsByTask(), and reg().

_tasks

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

private

The registered tasks.

Definition at line 129 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