ActionWarehouse Class Reference

Storage for action instances. More...

#include <ActionWarehouse.h>

Inheritance diagram for ActionWarehouse:

Public Member Functions
	ActionWarehouse (MooseApp &app, Syntax &syntax, ActionFactory &factory)
	~ActionWarehouse ()
void	build ()
	Builds all auto-buildable tasks.
void	clear ()
	This method deletes all of the Actions in the warehouse.
bool	empty () const
	returns a Boolean indicating whether the warehouse is empty or not.
void	addActionBlock (std::shared_ptr< Action > blk)
	This method add an Action instance to the warehouse.
void	checkUnsatisfiedActions () const
	This method checks the actions stored in the warehouse against the list of required registered actions to see if all of them have been satisfied.
void	printActionDependencySets () const
	This method is used only during debugging when show_actions is set to true.
void	printInputFile (std::ostream &out)
	This method uses the Actions in the warehouse to reproduce the input file.
const std::vector< std::shared_ptr< Action > > &	allActionBlocks () const
	Returns a reference to all of the actions.
const std::list< Action * > &	getActionListByName (const std::string &task) const
	Retrieve a constant list of Action pointers associated with the passed in task.
template<class T >
const T &	getAction (const std::string &name) const
	Retrieve an action with its name and the desired type.
template<class T >
T &	getAction (const std::string &name)
template<class T >
T *	getPhysics (const std::string &name) const
	Retrieve a Physics with its name and the desired type.
template<class T >
std::vector< const T * >	getActions ()
	Retrieve all actions in a specific type ordered by their names.
template<class T >
std::vector< T * >	getPhysics ()
	Retrieve all Physics with a specific type ordered by their names.
template<class T >
const T *	getActionByTask (const std::string &task)
	Retrieve the action on a specific task with its type.
void	setFinalTask (const std::string &task)
bool	hasActions (const std::string &task) const
	Check if Actions associated with passed in task exist.
void	executeAllActions ()
	This method loops over all actions in the warehouse and executes them.
void	executeActionsWithAction (const std::string &task_name)
	This method executes only the actions in the warehouse that satisfy the task passed in.
void	showActionDependencies (bool state=true)
	This method sets a Boolean which is used to print information about action dependencies before various warehouse operations during the problem setup phase.
void	showActions (bool state=true)
	This method sets a Boolean which is used to show information about action execution of various warehouse operations during the problem setup phase.
void	showParser (bool state=true)
	This method sets a Boolean which is used to show debugging information when actions are inserted in the warehouse by the parser.
Syntax &	syntax ()
std::shared_ptr< MooseMesh > &	mesh ()
const std::shared_ptr< MooseMesh > &	getMesh () const
std::shared_ptr< MooseMesh > &	displacedMesh ()
const std::shared_ptr< MooseMesh > &	getDisplacedMesh () const
std::shared_ptr< FEProblemBase > &	problemBase ()
std::shared_ptr< FEProblem >	problem ()
MooseApp &	mooseApp ()
const std::string &	getMooseAppName ()
const std::string &	getCurrentTaskName () const
const Action *	getCurrentAction () const
std::string	getCurrentActionName () const
bool	hasTask (const std::string &task) const
bool	isTaskComplete (const std::string &task) const
ActionIterator	actionBlocksWithActionBegin (const std::string &task)
	Iterators to the Actions in the warehouse.
ActionIterator	actionBlocksWithActionEnd (const std::string &task)

Public Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Protected Member Functions
void	buildBuildableActions (const std::string &task)
	This method auto-builds all Actions that needs to be built and adds them to ActionWarehouse.
std::vector< UserObjectName >	getUserObjectParamDependencies (const InputParameters &params) const
void	sortUserObjectActions (std::list< Action * > &actions) const
	Reorder the UserObject-constructing actions actions so that a UserObject that references another (through a UserObjectName parameter) is constructed after the one it references.

Protected Attributes
std::vector< std::shared_ptr< Action > >	_all_ptrs
MooseApp &	_app
	The MooseApp this Warehouse is associated with.
Syntax &	_syntax
	Reference to a "syntax" of actions.
ActionFactory &	_action_factory
	The Factory that builds Actions.
std::map< std::string, std::list< Action * > >	_action_blocks
	Pointers to the actual parsed input file blocks.
std::vector< std::string >	_ordered_names
	The container that holds the sorted action names from the DependencyResolver.
std::set< std::string >	_completed_tasks
	The completed tasks.
std::set< std::string >	_unsatisfied_dependencies
	Use to store the current list of unsatisfied dependencies.
bool	_generator_valid
	Flag to indicate whether or not there is an active iterator on this class.
bool	_show_action_dependencies
	Whether or not the action warehouse prints the action dependency information.
bool	_show_actions
	Whether or not the action warehouse prints the action execution information.
bool	_show_parser
	Whether or not to print messages when actions are inserted in the warehouse by the parser.
std::string	_current_task
Action *	_current_action
std::shared_ptr< MooseMesh >	_mesh
	Mesh class.
std::shared_ptr< MooseMesh >	_displaced_mesh
	Possible mesh for displaced problem.
std::shared_ptr< FEProblemBase >	_problem
	Problem class.

Private Attributes
std::string	_final_task
	Last task to run before (optional) early termination - blank means no early termination.
const std::list< Action * >	_empty_action_list
std::mutex	_completed_tasks_mutex
	Mutex for preventing read/write races for _completed_tasks.

Detailed Description

Storage for action instances.

Definition at line 35 of file ActionWarehouse.h.

Constructor & Destructor Documentation

ActionWarehouse()

ActionWarehouse::ActionWarehouse	(	MooseApp &	app,
		Syntax &	syntax,
		ActionFactory &	factory
	)

Definition at line 109 of file ActionWarehouse.C.

  : ConsoleStreamInterface(app),
    _app(app),
    _syntax(syntax),
    _action_factory(factory),
    _generator_valid(false),
    _show_action_dependencies(false),
    _show_actions(false),
    _show_parser(false),
    _current_action(nullptr),
    _mesh(nullptr),
    _displaced_mesh(nullptr)
{
}

~ActionWarehouse()

ActionWarehouse::~ActionWarehouse

(

)

Definition at line 124 of file ActionWarehouse.C.

{}

Member Function Documentation

actionBlocksWithActionBegin()

ActionIterator ActionWarehouse::actionBlocksWithActionBegin

(

const std::string &

task

)

Iterators to the Actions in the warehouse.

Iterators should always be used when executing Actions to capture dynamically added Actions (meta-Actions). Meta-Actions are allowed to create and add additional Actions to the warehouse on the fly. Those Actions will fire as long as their associated task hasn't already passed (i.e. matches or is later).

Definition at line 257 of file ActionWarehouse.C.

{
  return _action_blocks[task].begin();
}

Referenced by SetupDampersAction::act(), executeActionsWithAction(), and CommonOutputAction::hasConsole().

actionBlocksWithActionEnd()

ActionIterator ActionWarehouse::actionBlocksWithActionEnd

(

const std::string &

task

)

Definition at line 263 of file ActionWarehouse.C.

{
  return _action_blocks[task].end();
}

Referenced by SetupDampersAction::act(), executeActionsWithAction(), and CommonOutputAction::hasConsole().

addActionBlock()

void ActionWarehouse::addActionBlock

(

std::shared_ptr< Action >

blk

)

This method add an Action instance to the warehouse.

Note: This routine uses the XTerm colors directly which is not advised for general purpose output coloring. Most users should prefer using Problem::colorText() which respects the "color_output" option for terminals that do not support coloring. Since this routine is intended for debugging only and runs before several objects exist in the system, we are just using the constants directly.

We need to see if the current Action satisfies multiple tasks. There are a few cases to consider:

1. The current Action is registered with multiple syntax blocks. In this case we can only use the current instance to satisfy the specific task listed for this syntax block. We can detect this case by inspecting whether it has a "specific task name" set in the Action instance.
2. This action does not have a valid "registered identifier" set in the Action instance. This means that this Action was not built by the Parser. It was most likely created through a Meta-Action (See Case 3 for exception). In this case, the ActionFactory itself would have already set the task it found from the build info used to construct the Action so we'd arbitrarily satisfy a single task in this case.
3. The current Action is registered with only a single syntax block. In this case we can simply re-use the current instance to act and satisfy all registered tasks. This is the normal case where we have a Parser-built Action that does not have a specific task name to satisfy. We will use the Action "type" to retrieve the list of tasks that this Action may satisfy.

Definition at line 161 of file ActionWarehouse.C.

{
  std::string registered_identifier =
      action->parameters().get<std::string>("registered_identifier");
  std::set<std::string> tasks;
 
  if (_show_parser)
    Moose::err << COLOR_DEFAULT << "Parsing Syntax:        " << COLOR_GREEN << action->name()
               << '\n'
               << COLOR_DEFAULT << "Building Action:       " << COLOR_DEFAULT << action->type()
               << '\n'
               << COLOR_DEFAULT << "Registered Identifier: " << COLOR_GREEN << registered_identifier
               << '\n'
               << COLOR_DEFAULT << "Specific Task:         " << COLOR_CYAN
               << action->specificTaskName() << std::endl;
 
  if (action->specificTaskName() != "") // Case 1
    tasks.insert(action->specificTaskName());
  else if (registered_identifier == "" &&
           _syntax.getNonDeprecatedSyntaxByAction(action->type()).size() > 1) // Case 2
  {
    std::set<std::string> local_tasks = action->getAllTasks();
    mooseAssert(local_tasks.size() == 1, "More than one task inside of the " << action->name());
    tasks.insert(*local_tasks.begin());
  }
  else // Case 3
    tasks = _action_factory.getTasksByAction(action->type());
 
  // TODO: Now we need to weed out the double registrations!
  for (const auto & task : tasks)
  {
    // Some error checking
    if (!_syntax.hasTask(task))
      mooseError("A(n) ", task, " is not a registered task");
 
    // Make sure that the ObjectAction task and Action task are consistent
    // otherwise that means that is action was built by the wrong type
    std::shared_ptr<MooseObjectAction> moa = std::dynamic_pointer_cast<MooseObjectAction>(action);
    if (moa.get())
    {
      const InputParameters & mparams = moa->getObjectParams();
 
      if (mparams.hasBase())
      {
        const std::string & base = mparams.getBase();
        if (!_syntax.verifyMooseObjectTask(base, task))
          mooseError("Task ", task, " is not registered to build ", base, " derived objects");
      }
      else
        mooseError("Unable to locate registered base parameter for ", moa->getMooseObjectType());
    }
 
    // Add the current task to current action
    action->appendTask(task);
 
    if (_show_parser)
      Moose::err << COLOR_YELLOW << "Adding Action:         " << COLOR_DEFAULT << action->type()
                 << " (" << COLOR_YELLOW << task << COLOR_DEFAULT << ")" << std::endl;
 
    // Add it to the warehouse
    _action_blocks[task].push_back(action.get());
  }
  _all_ptrs.push_back(action);
 
  if (_show_parser)
    Moose::err << std::endl;
}

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

allActionBlocks()

const std::vector< std::shared_ptr< Action > > & ActionWarehouse::allActionBlocks

(

)

const

Returns a reference to all of the actions.

Definition at line 269 of file ActionWarehouse.C.

{
  return _all_ptrs;
}

Referenced by AddRelationshipManager::act().

build()

void ActionWarehouse::build

(

)

Builds all auto-buildable tasks.

This method is typically called after the Parser has created Actions based on an input file.

Definition at line 135 of file ActionWarehouse.C.

{
  _ordered_names = _syntax.getSortedTask();
  for (const auto & name : _ordered_names)
    buildBuildableActions(name);
}

Referenced by MooseApp::createMinimalApp(), and MooseApp::setupOptions().

buildBuildableActions()

void ActionWarehouse::buildBuildableActions ( const std::string &  task )

protected

This method auto-builds all Actions that needs to be built and adds them to ActionWarehouse.

An Action needs to be built if it is associated with a task that is marked as required and all of it's parameters are valid (are not required or have default values supplied).

Parameters

task	The name of the task to find and build Actions for.

Definition at line 292 of file ActionWarehouse.C.

{
  if (_syntax.shouldAutoBuild(task) && _action_blocks[task].empty())
  {
    bool ret_value = false;
    auto it_pair = _action_factory.getActionsByTask(task);
    for (const auto & action_pair : as_range(it_pair))
    {
      const auto & type = action_pair.second;
      InputParameters params = _action_factory.getValidParams(type);
      params.set<ActionWarehouse *>("awh") = this;
 
      std::string name = "auto_" + type;
      std::transform(
          name.begin(), name.end(), name.begin(), [](const auto v) { return std::tolower(v); });
 
      if (params.areAllRequiredParamsValid())
      {
        params.set<std::string>("registered_identifier") = "(AutoBuilt)";
        addActionBlock(_action_factory.create(type, name, params));
        ret_value = true;
      }
    }
 
    if (!ret_value)
      _unsatisfied_dependencies.insert(task);
  }
}

Referenced by build().

checkUnsatisfiedActions()

void ActionWarehouse::checkUnsatisfiedActions

(

)

const

This method checks the actions stored in the warehouse against the list of required registered actions to see if all of them have been satisfied.

It should be called before running a MOOSE problem

Definition at line 322 of file ActionWarehouse.C.

{
  std::stringstream oss;
  bool empty = true;
 
  for (const auto & udep : _unsatisfied_dependencies)
  {
    if (_action_blocks.find(udep) == _action_blocks.end())
    {
      if (empty)
        empty = false;
      else
        oss << " ";
      oss << udep;
    }
  }
 
  if (!empty)
    mooseError(
        std::string(
            "The following unsatisfied actions where found while setting up the MOOSE problem:\n") +
        oss.str() + "\n");
}

Referenced by CheckIntegrityAction::act().

clear()

void ActionWarehouse::clear

(

)

This method deletes all of the Actions in the warehouse.

Definition at line 143 of file ActionWarehouse.C.

{
  for (auto & ptr : _all_ptrs)
    ptr.reset();
 
  _action_blocks.clear();
  _generator_valid = false;
 
  // Due to the way ActionWarehouse is cleaned up (see MooseApp's
  // destructor) we must guarantee that ActionWarehouse::clear()
  // releases all the resources which have to be released _before_ the
  // _comm object owned by the MooseApp is destroyed.
  _problem.reset();
  _displaced_mesh.reset();
  _mesh.reset();
}

displacedMesh()

std::shared_ptr< MooseMesh > & ActionWarehouse::displacedMesh ( )

inline

Definition at line 283 of file ActionWarehouse.h.

{ return _displaced_mesh; }

Referenced by MooseApp::attachRelationshipManagers(), and MooseApp::removeRelationshipManager().

empty()

bool ActionWarehouse::empty ( ) const

inline

returns a Boolean indicating whether the warehouse is empty or not.

Definition at line 55 of file ActionWarehouse.h.

{ return _action_blocks.empty(); }

Referenced by checkUnsatisfiedActions().

executeActionsWithAction()

void ActionWarehouse::executeActionsWithAction

(

const std::string &

task_name

)

This method executes only the actions in the warehouse that satisfy the task passed in.

Definition at line 452 of file ActionWarehouse.C.

{
  // Set the current task name
  _current_task = task;
 
  // UserObjects may reference other UserObjects in their constructors (e.g. through a
  // UserObjectName parameter). Construct them in dependency order so the input file does not have
  // to declare a referenced UserObject before the UserObject that uses it.
  if (task == "add_user_object")
    sortUserObjectActions(_action_blocks[task]);
 
  for (auto it = actionBlocksWithActionBegin(task); it != actionBlocksWithActionEnd(task); ++it)
  {
    _current_action = *it;
 
    if (_show_actions)
    {
      MemoryUtils::Stats stats;
      MemoryUtils::getMemoryStats(stats);
      auto usage =
          MemoryUtils::convertBytes(stats._physical_memory, MemoryUtils::MemUnits::Megabytes);
      _console << "[DBG][ACT] "
               << "TASK (" << COLOR_YELLOW << std::setw(24) << task << COLOR_DEFAULT << ") "
               << "TYPE (" << COLOR_YELLOW << std::setw(32) << _current_action->type()
               << COLOR_DEFAULT << ") "
               << "NAME (" << COLOR_YELLOW << std::setw(16) << _current_action->name()
               << COLOR_DEFAULT << ") Memory usage " << usage << "MB" << std::endl;
    }
 
    _current_action->timedAct();
  }
 
  _current_action = nullptr;
}

Referenced by executeAllActions().

executeAllActions()

void ActionWarehouse::executeAllActions

(

)

This method loops over all actions in the warehouse and executes them.

Meta-actions may add new actions to the warehouse on the fly and they will still be executed in order

Definition at line 419 of file ActionWarehouse.C.

{
  _completed_tasks.clear();
 
  if (_show_action_dependencies)
  {
    _console << "[DBG][ACT] Action Dependency Sets:\n";
    printActionDependencySets();
 
    _console << "\n[DBG][ACT] Executing actions:" << std::endl;
  }
 
  for (const auto & task : _ordered_names)
  {
    executeActionsWithAction(task);
    std::scoped_lock lock(_completed_tasks_mutex);
    _completed_tasks.insert(task);
    if (_final_task != "" && task == _final_task)
      break;
  }
 
  if (_show_actions)
  {
    MemoryUtils::Stats stats;
    MemoryUtils::getMemoryStats(stats);
    auto usage =
        MemoryUtils::convertBytes(stats._physical_memory, MemoryUtils::MemUnits::Megabytes);
    _console << "[DBG][ACT] Finished executing all actions with memory usage " << usage << "MB\n"
             << std::endl;
  }
}

Referenced by MooseApp::runInputFile().

getAction() [1/2]

template<class T >

T & ActionWarehouse::getAction ( const std::string &  name )

inline

Definition at line 139 of file ActionWarehouse.h.

  {
    return const_cast<T &>(static_cast<const ActionWarehouse *>(this)->getAction<T>(name));
  }

getAction() [2/2]

template<class T >

const T & ActionWarehouse::getAction ( const std::string &  name ) const

inline

Retrieve an action with its name and the desired type.

Parameters

name	The action name.

Definition at line 111 of file ActionWarehouse.h.

  {
    typename std::shared_ptr<T> p;
    for (auto act_ptr : _all_ptrs)
    {
      if (act_ptr->name() == name)
      {
        p = std::dynamic_pointer_cast<T>(act_ptr);
        if (p)
          break;
      }
    }
    if (!p)
    {
      std::vector<std::string> all_names;
      for (auto act_ptr : _all_ptrs)
        if (!act_ptr->name().empty())
          all_names.push_back(act_ptr->name());
        else
          all_names.push_back("unnamed");
      mooseError("Action with name '",
                 name,
                 "' does not exist.\n These are the Actions that do exist:",
                 Moose::stringify(all_names));
    }
    return *p;
  }

Referenced by ComponentJunction::addMeshGenerators(), and PhysicsBase::getActionComponent().

getActionByTask()

template<class T >

const T * ActionWarehouse::getActionByTask ( const std::string &  task )

inline

Retrieve the action on a specific task with its type.

Error will be thrown if more than one actions are found.

Parameters

task	The task name.

Returns

The action pointer. Null means that such an action does not exist.

Definition at line 207 of file ActionWarehouse.h.

  {
    const auto it = _action_blocks.find(task);
    if (it == _action_blocks.end())
      return nullptr;
 
    T * p = nullptr;
    for (const auto & action : it->second)
    {
      T * tp = dynamic_cast<T *>(action);
      if (tp)
      {
        if (p)
          mooseError("More than one actions have been detected in getActionByTask for the task '",
                     task,
                     "' in the app '",
                     getMooseAppName(),
                     "'");
        else
          p = tp;
      }
    }
    return p;
  }

Referenced by CreateProblemDefaultAction::act().

getActionListByName()

const std::list< Action * > & ActionWarehouse::getActionListByName

(

const std::string &

task

)

const

Retrieve a constant list of Action pointers associated with the passed in task.

Empty list will be returned if no actions are associated with the task.

Definition at line 275 of file ActionWarehouse.C.

{
  const auto it = _action_blocks.find(task);
  if (it == _action_blocks.end())
    return _empty_action_list;
  else
    return it->second;
}

Referenced by ElementIDOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), SetupTimeStepperAction::act(), MooseApp::getCheckpointDirectories(), and OutputWarehouse::getOutputNames().

getActions()

template<class T >

std::vector< const T * > ActionWarehouse::getActions ( )

inline

Retrieve all actions in a specific type ordered by their names.

Definition at line 165 of file ActionWarehouse.h.

  {
    // we need to create the map first to ensure that all actions in the map are unique
    // and the actions are sorted by their names
    typename std::map<std::string, const std::shared_ptr<T>> actions;
    for (auto act_ptr : _all_ptrs)
    {
      auto p = std::dynamic_pointer_cast<T>(act_ptr);
      if (p)
        actions.insert(std::make_pair(act_ptr->name(), p));
    }
    // construct the vector from the map entries
    std::vector<const T *> action_vector;
    for (auto & pair : actions)
      action_vector.push_back(pair.second.get());
    return action_vector;
  }

Referenced by CombineComponentsMeshes::act(), Console::Console(), NEML2Action::getCommonAction(), PhysicsBase::getCoupledPhysics(), PhysicsBase::getCoupledPhysics(), JSONOutput::outputReporters(), MooseApp::setupOptions(), and PetscOutput::solveSetup().

getCurrentAction()

const Action * ActionWarehouse::getCurrentAction ( ) const

inline

Returns

The current action that is running, if any

Definition at line 295 of file ActionWarehouse.h.

{ return _current_action; }

Referenced by MooseApp::getCurrentActionHitNode(), and getCurrentActionName().

getCurrentActionName()

std::string ActionWarehouse::getCurrentActionName

(

)

const

Returns

The name of the current action that is running

Definition at line 543 of file ActionWarehouse.C.

{
  return getCurrentAction()->parameters().getHitNode()->fullpath();
}

Referenced by DumpObjectsProblem::dumpObjectHelper(), and DumpObjectsProblem::dumpVariableHelper().

getCurrentTaskName()

const std::string & ActionWarehouse::getCurrentTaskName ( ) const

inline

Definition at line 290 of file ActionWarehouse.h.

{ return _current_task; }

Referenced by MeshGeneratorSystem::appendingMeshGenerators(), MooseApp::constructingMeshGenerators(), MeshGeneratorSystem::createAddedMeshGenerators(), MeshGeneratorSystem::createMeshGeneratorOrder(), MeshGeneratorSystem::getCSGBaseGeneratorOutput(), MeshGeneratorSystem::getMeshGeneratorOutput(), and MeshGenerator::setMeshProperty().

getDisplacedMesh()

const std::shared_ptr< MooseMesh > & ActionWarehouse::getDisplacedMesh ( ) const

inline

Definition at line 284 of file ActionWarehouse.h.

{ return _displaced_mesh; }

Referenced by MooseApp::getRelationshipManagerInfo().

getMesh()

const std::shared_ptr< MooseMesh > & ActionWarehouse::getMesh ( ) const

inline

Definition at line 281 of file ActionWarehouse.h.

{ return _mesh; }

Referenced by MeshGeneratorSystem::createAddedMeshGenerators(), MeshGeneratorSystem::dataDrivenError(), MooseApp::getRelationshipManagerInfo(), and CylinderComponent::setupComponent().

getMooseAppName()

const std::string & ActionWarehouse::getMooseAppName

(

)

Definition at line 549 of file ActionWarehouse.C.

{
  return _app.name();
}

Referenced by getActionByTask().

getPhysics() [1/2]

template<class T >

std::vector< T * > ActionWarehouse::getPhysics ( )

inline

Retrieve all Physics with a specific type ordered by their names.

Definition at line 187 of file ActionWarehouse.h.

  {
    const auto physics_vector = getActions<T>();
    for (const auto phys_ptr : physics_vector)
      if (!dynamic_cast<const PhysicsBase *>(phys_ptr))
        mooseError("The Physics requested of type '",
                   MooseUtils::prettyCppType<T>(),
                   "' and name '",
                   phys_ptr->name(),
                   "' is not derived from the PhysicsBase class");
    return physics_vector;
  }

getPhysics() [2/2]

template<class T >

T * ActionWarehouse::getPhysics ( const std::string &  name ) const

inline

Retrieve a Physics with its name and the desired type.

Parameters

name	The action name.

Definition at line 149 of file ActionWarehouse.h.

  {
    auto physics = const_cast<T *>(&getAction<T>(name));
    if (!dynamic_cast<const PhysicsBase *>(physics))
      mooseError("The Physics requested of type '",
                 MooseUtils::prettyCppType<T>(),
                 "' and name '",
                 name,
                 "' is not derived from the PhysicsBase class");
    return physics;
  }

Referenced by ComponentPhysicsInterface::ComponentPhysicsInterface(), and ComponentPhysicsInterface::physicsExists().

getUserObjectParamDependencies()

std::vector< UserObjectName > ActionWarehouse::getUserObjectParamDependencies ( const InputParameters &  params ) const

protected

Returns

The names of the UserObjects referenced by params through its UserObjectName (or std::vector<UserObjectName>) parameters. Mirrors MeshGeneratorSystem::getMeshGeneratorParamDependencies.

Definition at line 31 of file ActionWarehouse.C.

{
  std::vector<UserObjectName> dependencies;
  for (const auto & [_, param] : params)
  {
    if (const auto dependency =
            dynamic_cast<const libMesh::Parameters::Parameter<UserObjectName> *>(param.get()))
    {
      const auto & uo_name = dependency->get();
      if (!uo_name.empty())
        dependencies.push_back(uo_name);
    }
    else if (const auto vector_dependency =
                 dynamic_cast<const libMesh::Parameters::Parameter<std::vector<UserObjectName>> *>(
                     param.get()))
      for (const auto & uo_name : vector_dependency->get())
        if (!uo_name.empty())
          dependencies.push_back(uo_name);
  }
  return dependencies;
}

Referenced by sortUserObjectActions().

hasActions()

bool ActionWarehouse::hasActions

(

const std::string &

task

)

const

Check if Actions associated with passed in task exist.

Definition at line 285 of file ActionWarehouse.C.

{
  auto it = _action_blocks.find(task);
  return it != _action_blocks.end() && !it->second.empty();
}

Referenced by ElementIDOutputAction::act(), CreateExecutionerAction::act(), CreateMeshSetupActionsForComponents::act(), MaterialOutputAction::act(), ReadExecutorParamsAction::act(), and OutputWarehouse::getOutputNames().

hasTask()

bool ActionWarehouse::hasTask

(

const std::string &

task

)

const

Returns

True if a task with the name task is registered.

Definition at line 555 of file ActionWarehouse.C.

{
  return _action_factory.isRegisteredTask(task);
}

Referenced by AddActionComponentAction::AddActionComponentAction(), isTaskComplete(), and OutputWarehouse::mooseConsole().

isTaskComplete()

bool ActionWarehouse::isTaskComplete

(

const std::string &

task

)

const

Returns

True if the registered task with the name task is complete.

Definition at line 561 of file ActionWarehouse.C.

{
  if (!hasTask(task))
    mooseError("\"", task, "\" is not a registered task.");
  std::scoped_lock lock(_completed_tasks_mutex);
  return _completed_tasks.count(task);
}

Referenced by OutputWarehouse::mooseConsole(), PostprocessorInterface::postprocessorsAdded(), ReporterInterface::reportersAdded(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

mesh()

std::shared_ptr< MooseMesh > & ActionWarehouse::mesh ( )

inline

Definition at line 280 of file ActionWarehouse.h.

{ return _mesh; }

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), MooseApp::attachRelationshipManagers(), and MooseApp::removeRelationshipManager().

mooseApp()

MooseApp & ActionWarehouse::mooseApp ( )

inline

Definition at line 288 of file ActionWarehouse.h.

{ return _app; }

Referenced by ExodusFormatter::printInputFile(), and SetupDebugAction::SetupDebugAction().

printActionDependencySets()

void ActionWarehouse::printActionDependencySets

(

)

const

This method is used only during debugging when show_actions is set to true.

It prints all of the actions sets in the correct dependency resolved order with all of the Action objects inside.

Note: This routine uses the XTerm colors directly which is not advised for general purpose output coloring. Most users should prefer using Problem::colorText() which respects the "color_output" option for terminals that do not support coloring. Since this routine is intended for debugging only and runs before several objects exist in the system, we are just using the constants directly.

Definition at line 347 of file ActionWarehouse.C.

{
  std::ostringstream oss;
 
  const auto & ordered_names = _syntax.getSortedTaskSet();
  for (const auto & task_vector : ordered_names)
  {
    oss << "[DBG][ACT] (" << COLOR_YELLOW;
    std::copy(
        task_vector.begin(), task_vector.end(), infix_ostream_iterator<std::string>(oss, ", "));
    oss << COLOR_DEFAULT << ")\n";
 
    std::set<std::string> task_set(task_vector.begin(), task_vector.end());
    for (const auto & task : task_set)
    {
      if (_action_blocks.find(task) == _action_blocks.end())
        continue;
 
      for (const auto & act : _action_blocks.at(task))
      {
        // The Syntax of the Action if it exists
        if (act->name() != "")
          oss << "[DBG][ACT]\t" << COLOR_GREEN << act->name() << COLOR_DEFAULT << '\n';
 
        // The task sets
        oss << "[DBG][ACT]\t" << act->type();
        const std::set<std::string> tasks = act->getAllTasks();
        if (tasks.size() > 1)
        {
          oss << " (";
          // Break the current Action's tasks into 2 sets, those intersecting with current set and
          // then the difference.
          std::set<std::string> intersection, difference;
          std::set_intersection(tasks.begin(),
                                tasks.end(),
                                task_set.begin(),
                                task_set.end(),
                                std::inserter(intersection, intersection.end()));
          std::set_difference(tasks.begin(),
                              tasks.end(),
                              intersection.begin(),
                              intersection.end(),
                              std::inserter(difference, difference.end()));
 
          oss << COLOR_CYAN;
          std::copy(intersection.begin(),
                    intersection.end(),
                    infix_ostream_iterator<std::string>(oss, ", "));
          oss << COLOR_MAGENTA << (difference.empty() ? "" : ", ");
          std::copy(
              difference.begin(), difference.end(), infix_ostream_iterator<std::string>(oss, ", "));
          oss << COLOR_DEFAULT << ")";
        }
        oss << '\n';
      }
    }
  }
 
  if (_show_action_dependencies)
    _console << oss.str() << std::endl;
}

Referenced by executeAllActions().

printInputFile()

void ActionWarehouse::printInputFile

(

std::ostream &

out

)

This method uses the Actions in the warehouse to reproduce the input file.

This method is useful for debugging as it can assist in finding difficult to track parsing or input file problems.

Parameters

out	A writable ostream object where the output will be sent.

Definition at line 488 of file ActionWarehouse.C.

{
  InputFileFormatter tree(false);
 
  std::map<std::string, std::vector<Action *>>::iterator iter;
 
  std::vector<Action *> ordered_actions;
  for (const auto & block : _action_blocks)
    for (const auto & act : block.second)
      ordered_actions.push_back(act);
 
  for (const auto & act : ordered_actions)
  {
    std::string name;
    if (act->parameters().blockFullpath() != "")
      name = act->parameters().blockFullpath();
    else
      name = act->name();
    const std::set<std::string> & tasks = act->getAllTasks();
    mooseAssert(!tasks.empty(), "Task list is empty");
 
    bool is_parent;
    if (_syntax.isAssociated(name, &is_parent) != "")
    {
      const auto & all_params = _app.getInputParameterWarehouse().getInputParameters();
      InputParameters & params = *(all_params.find(act->uniqueActionName())->second.get());
 
      // temporarily allow input parameter copies required by the input file formatter
      params.allowCopy(true);
 
      // TODO: Do we need to insert more nodes for each task?
      tree.insertNode(name, *tasks.begin(), true, &params);
      params.allowCopy(false);
 
      MooseObjectAction * moose_object_action = dynamic_cast<MooseObjectAction *>(act);
      if (moose_object_action)
      {
        InputParameters obj_params = moose_object_action->getObjectParams();
        tree.insertNode(name, *tasks.begin(), false, &obj_params);
      }
    }
  }
 
  out << tree.print("");
}

Referenced by Console::outputInput(), and ExodusFormatter::printInputFile().

problem()

std::shared_ptr< FEProblem > ActionWarehouse::problem

(

)

Definition at line 535 of file ActionWarehouse.C.

{
  mooseDeprecated(
      "ActionWarehouse::problem() is deprecated, please use ActionWarehouse::problemBase() \n");
  return std::dynamic_pointer_cast<FEProblem>(_problem);
}

problemBase()

std::shared_ptr< FEProblemBase > & ActionWarehouse::problemBase ( )

inline

Definition at line 286 of file ActionWarehouse.h.

{ return _problem; }

Referenced by ActionComponent::getProblem(), and Factory::initialize().

setFinalTask()

void ActionWarehouse::setFinalTask

(

const std::string &

task

)

Definition at line 127 of file ActionWarehouse.C.

{
  if (!_syntax.hasTask(task))
    mooseError("cannot use unregistered task '", task, "' as final task");
  _final_task = task;
}

Referenced by MooseApp::setupOptions().

showActionDependencies()

void ActionWarehouse::showActionDependencies ( bool  state = true )

inline

This method sets a Boolean which is used to print information about action dependencies before various warehouse operations during the problem setup phase.

Parameters

state

Flag indicating whether to print action dependencies.

Definition at line 256 of file ActionWarehouse.h.

{ _show_action_dependencies = state; }

Referenced by SetupDebugAction::SetupDebugAction().

showActions()

void ActionWarehouse::showActions ( bool  state = true )

inline

This method sets a Boolean which is used to show information about action execution of various warehouse operations during the problem setup phase.

Parameters

state

Flag indicating whether to show action information.

Definition at line 263 of file ActionWarehouse.h.

{ _show_actions = state; }

Referenced by SetupDebugAction::SetupDebugAction().

showParser()

void ActionWarehouse::showParser ( bool  state = true )

inline

This method sets a Boolean which is used to show debugging information when actions are inserted in the warehouse by the parser.

Parameters

state

Flag indicating whether to show action insertion.

Definition at line 270 of file ActionWarehouse.h.

{ _show_parser = state; }

Referenced by SetupDebugAction::SetupDebugAction().

sortUserObjectActions()

void ActionWarehouse::sortUserObjectActions ( std::list< Action * > &  actions ) const

protected

Reorder the UserObject-constructing actions actions so that a UserObject that references another (through a UserObjectName parameter) is constructed after the one it references.

This makes the input order-agnostic: a referenced UserObject no longer has to be declared before the UserObject that uses it in its constructor. Mirrors the dependency resolution MeshGeneratorSystem performs for mesh generators.

Definition at line 54 of file ActionWarehouse.C.

{
  // We key on act->name() because for a MooseObjectAction the action name is exactly the name the
  // UserObject is constructed under (see AddUserObjectAction), so a UserObjectName parameter value
  // matches the action that builds the referenced object.
  std::map<std::string, Action *> action_for_uo_name;
  for (const auto act : actions)
    if (dynamic_cast<MooseObjectAction *>(act))
      action_for_uo_name.emplace(act->name(), act);
    // A Physics does not build its UserObjects under its own action name, so it declares the names
    // it supplies through getSuppliedUserObjects(). Key those to the Physics action so an object
    // referencing a Physics-supplied UserObject is constructed after the Physics adds it.
    else if (const auto physics = dynamic_cast<const PhysicsBase *>(act))
      for (const auto & uo_name : physics->getSuppliedUserObjects())
        action_for_uo_name.emplace(uo_name, act);
 
  // Seed the resolver in the current (input-file) order so that independent UserObjects keep their
  // input order (DependencyResolver resolves in insertion order modulo dependencies).
  DependencyResolver<Action *> resolver;
  for (const auto act : actions)
    resolver.addItem(act);
 
  for (const auto act : actions)
  {
    // A MooseObjectAction carries its dependencies in the parameters of the object it builds. Any
    // other action that consumes a UserObject (e.g. a Physics that programmatically adds one) names
    // it in the action's own parameters, so the dependency is ordered against just the same.
    const auto moose_object_action = dynamic_cast<MooseObjectAction *>(act);
    const auto & relevant_params =
        moose_object_action ? moose_object_action->getObjectParams() : act->parameters();
    for (const auto & dep_name : getUserObjectParamDependencies(relevant_params))
    {
      const auto it = action_for_uo_name.find(dep_name);
      if (it != action_for_uo_name.end() && it->second != act)
        // act references the UserObject built by it->second, which must be constructed first
        resolver.addEdge(it->second, act);
    }
  }
 
  // A UserObjectName parameter does not necessarily denote a construction-time dependency: many
  // UserObjects only resolve a referenced UserObject during initialSetup() or execution. Mutually
  // referencing UserObjects therefore form a cycle here even though they construct fine in input
  // order. So a cycle is not an error - fall back to the original input order, which is the
  // behavior prior to this sorting. A genuine construction-time cycle still surfaces as the usual
  // "UserObject not found" error when the object is constructed.
  try
  {
    const auto & sorted = resolver.getSortedValues();
    actions.assign(sorted.begin(), sorted.end());
  }
  catch (const CyclicDependencyException<Action *> &)
  {
  }
}

Referenced by executeActionsWithAction().

syntax()

Syntax & ActionWarehouse::syntax ( )

inline

Definition at line 273 of file ActionWarehouse.h.

{ return _syntax; }

Referenced by DynamicObjectRegistrationAction::DynamicObjectRegistrationAction().

Member Data Documentation

_action_blocks

std::map<std::string, std::list<Action *> > ActionWarehouse::_action_blocks

protected

Pointers to the actual parsed input file blocks.

Definition at line 345 of file ActionWarehouse.h.

Referenced by actionBlocksWithActionBegin(), actionBlocksWithActionEnd(), addActionBlock(), buildBuildableActions(), checkUnsatisfiedActions(), clear(), empty(), executeActionsWithAction(), getActionByTask(), getActionListByName(), hasActions(), printActionDependencySets(), and printInputFile().

_action_factory

ActionFactory& ActionWarehouse::_action_factory

protected

The Factory that builds Actions.

Definition at line 343 of file ActionWarehouse.h.

Referenced by addActionBlock(), buildBuildableActions(), and hasTask().

_all_ptrs

std::vector<std::shared_ptr<Action> > ActionWarehouse::_all_ptrs

protected

Definition at line 336 of file ActionWarehouse.h.

Referenced by addActionBlock(), allActionBlocks(), clear(), getAction(), and getActions().

_app

MooseApp& ActionWarehouse::_app

protected

The MooseApp this Warehouse is associated with.

Definition at line 339 of file ActionWarehouse.h.

Referenced by getMooseAppName(), mooseApp(), and printInputFile().

_completed_tasks

std::set<std::string> ActionWarehouse::_completed_tasks

protected

The completed tasks.

Definition at line 349 of file ActionWarehouse.h.

Referenced by executeAllActions(), and isTaskComplete().

_completed_tasks_mutex

std::mutex ActionWarehouse::_completed_tasks_mutex

mutableprivate

Mutex for preventing read/write races for _completed_tasks.

Definition at line 393 of file ActionWarehouse.h.

Referenced by executeAllActions(), and isTaskComplete().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), executeActionsWithAction(), executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_current_action

Action* ActionWarehouse::_current_action

protected

Definition at line 371 of file ActionWarehouse.h.

Referenced by executeActionsWithAction(), and getCurrentAction().

_current_task

std::string ActionWarehouse::_current_task

protected

Definition at line 369 of file ActionWarehouse.h.

Referenced by executeActionsWithAction(), and getCurrentTaskName().

_displaced_mesh

std::shared_ptr<MooseMesh> ActionWarehouse::_displaced_mesh

protected

Possible mesh for displaced problem.

Definition at line 381 of file ActionWarehouse.h.

Referenced by clear(), displacedMesh(), and getDisplacedMesh().

_empty_action_list

const std::list<Action *> ActionWarehouse::_empty_action_list

private

Definition at line 390 of file ActionWarehouse.h.

Referenced by getActionListByName().

_final_task

std::string ActionWarehouse::_final_task

private

Last task to run before (optional) early termination - blank means no early termination.

Definition at line 388 of file ActionWarehouse.h.

Referenced by executeAllActions(), and setFinalTask().

_generator_valid

bool ActionWarehouse::_generator_valid

protected

Flag to indicate whether or not there is an active iterator on this class.

There can only be a single active iterator because of the potential for meta Actions to add new Actions into the warehouse on the fly

Definition at line 358 of file ActionWarehouse.h.

Referenced by clear().

_mesh

std::shared_ptr<MooseMesh> ActionWarehouse::_mesh

protected

Mesh class.

Definition at line 378 of file ActionWarehouse.h.

Referenced by clear(), getMesh(), and mesh().

_ordered_names

std::vector<std::string> ActionWarehouse::_ordered_names

protected

The container that holds the sorted action names from the DependencyResolver.

Definition at line 347 of file ActionWarehouse.h.

Referenced by build(), and executeAllActions().

_problem

std::shared_ptr<FEProblemBase> ActionWarehouse::_problem

protected

Problem class.

Definition at line 384 of file ActionWarehouse.h.

Referenced by clear(), problem(), and problemBase().

_show_action_dependencies

bool ActionWarehouse::_show_action_dependencies

protected

Whether or not the action warehouse prints the action dependency information.

Definition at line 361 of file ActionWarehouse.h.

Referenced by executeAllActions(), printActionDependencySets(), and showActionDependencies().

_show_actions

bool ActionWarehouse::_show_actions

protected

Whether or not the action warehouse prints the action execution information.

Definition at line 363 of file ActionWarehouse.h.

Referenced by executeActionsWithAction(), executeAllActions(), and showActions().

_show_parser

bool ActionWarehouse::_show_parser

protected

Whether or not to print messages when actions are inserted in the warehouse by the parser.

Definition at line 365 of file ActionWarehouse.h.

Referenced by addActionBlock(), and showParser().

_syntax

Syntax& ActionWarehouse::_syntax

protected

Reference to a "syntax" of actions.

Definition at line 341 of file ActionWarehouse.h.

Referenced by addActionBlock(), build(), buildBuildableActions(), printActionDependencySets(), printInputFile(), setFinalTask(), and syntax().

_unsatisfied_dependencies

std::set<std::string> ActionWarehouse::_unsatisfied_dependencies

protected

Use to store the current list of unsatisfied dependencies.

Definition at line 351 of file ActionWarehouse.h.

Referenced by buildBuildableActions(), and checkUnsatisfiedActions().

---

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

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