Syntax Class Reference

Holding syntax for parsing input files. More...

#include <Syntax.h>

Classes
struct	ActionInfo

Public Member Functions
	Syntax ()
void	registerTaskName (const std::string &task, bool should_auto_build=false)
	Method to register a new task.
void	registerTaskName (const std::string &task, const std::string &moose_object_type, bool should_auto_build=false)
	Method to register a new task (see overload method with same name).
void	appendTaskName (const std::string &task, const std::string &moose_object_type, bool deprecated)
	Method to associate another "allowed" pluggable MOOSE system to an existing registered task.
void	addDependency (const std::string &task, const std::string &pre_req)
void	addDependencySets (const std::string &action_sets)
	Adds all dependencies in a single call.
void	deleteTaskDependencies (const std::string &task)
	Deletes or removes the dependencies that this task depends on.
void	clearTaskDependencies ()
	Clears all tasks from the system object.
const std::vector< std::string > &	getSortedTask ()
	Get a list of serialized tasks in a correct dependency order.
const std::vector< std::vector< std::string > > &	getSortedTaskSet ()
	Get a list of serialized tasks in a correct dependency order.
bool	hasTask (const std::string &task) const
	Returns a Boolean indicating whether or not a task is registered with the syntax object.
bool	isActionRequired (const std::string &task) const
	Returns a Boolean indicating whether the specified task is required.
bool	shouldAutoBuild (const std::string &task) const
	Returns a Boolean indicating whether MOOSE should attempt to automatically create an Action to satisfy a task if an Action doesn't already exist to service that task.
void	registerActionSyntax (const std::string &action, const std::string &syntax, const std::string &task="", const std::string &file="", int line=-1)
	Registration function for associating Moose Actions with syntax.
void	removeAllActionsForSyntax (const std::string &syntax)
	De-registers all actions associated with a given syntax.
void	replaceActionSyntax (const std::string &action, const std::string &syntax, const std::string &task, const std::string &file="", int line=-1)
	Registration function that replaces existing Moose Actions with a completely new action Note: This function will remove all actions associated with this piece of syntax NOT just a single match of some kind.
void	registerSyntaxType (const std::string &syntax, const std::string &type)
	Register a type with a block.
const std::multimap< std::string, std::string > &	getAssociatedTypes () const
	Get a multimap of registered associations of syntax with type.
void	deprecateActionSyntax (const std::string &syntax)
	This method deprecates previously registered syntax.
void	deprecateActionSyntax (const std::string &syntax, const std::string &message)
std::string	deprecatedActionSyntaxMessage (const std::string syntax)
	Returns the deprecation message for a given syntax that has been deprecated by deprecateActionSyntax.
bool	isDeprecatedSyntax (const std::string &syntax) const
	Returns a Boolean indicating whether the syntax has been deprecated through a call to deprecateActionSyntax.
std::vector< std::string >	getSyntaxByAction (const std::string &action, const std::string &task="")
	Retrieve the syntax associated with the passed in action type string.
std::vector< std::string >	getNonDeprecatedSyntaxByAction (const std::string &action, const std::string &task="")
	Retrieve the non-deprecated syntax associated with the passed in action type string.
std::string	isAssociated (const std::string &real_id, bool *is_parent, const std::map< std::string, std::set< std::string > > &alt_map={}) const
	Method for determining whether a piece of syntax is associated with an Action an optional syntax map may be given to traverse instead of _syntax_to_actions TODO: I need a better name.
std::pair< std::multimap< std::string, ActionInfo >::const_iterator, std::multimap< std::string, ActionInfo >::const_iterator >	getActions (const std::string &syntax) const
	Returns a pair of multimap iterators to all the ActionInfo objects associated with a given piece of syntax.
const std::multimap< std::string, ActionInfo > &	getAssociatedActions () const
	Return all Syntax to Action associations.
bool	verifyMooseObjectTask (const std::string &base, const std::string &task) const
	Returns a Boolean indicating whether a task is associated with on of the MOOSE pluggable systems (BASE CLASSES).
FileLineInfo	getLineInfo (const std::string &syntax, const std::string &action, const std::string &task) const
	Gets the file and line where the syntax/action/task combo was registered.

Protected Attributes
std::map< std::string, bool >	_registered_tasks
	The list of registered tasks and a flag indicating whether or not they should be auto-built.
std::multimap< std::string, std::string >	_moose_systems_to_tasks
	The list of Moose system objects to tasks. This map indicates which tasks are allowed to build certain MooseObjects.
std::multimap< std::string, std::string >	_deprecated_list_moose_systems_to_tasks
	A list of Moose system objects to tasks that are deprecated for these systems.
DependencyResolver< std::string >	_tasks
	The dependency resolver.
std::multimap< std::string, ActionInfo >	_syntax_to_actions
	The syntax object to ActionInfo (Action+task) associations.
std::multimap< std::string, std::pair< std::string, std::string > >	_actions_to_syntax
	The ActionInfo (Action+task) to syntax associations (built only when needed) Action -> (Syntax, Task)
std::multimap< std::string, std::string >	_associated_types
	Syntax/Type association.
bool	_actions_to_syntax_valid
	Boolean indicating whether the _actions_to_syntax map is built and valid and synced.
std::map< std::string, std::string >	_deprecated_syntax
	The list of deprecated syntax items and the associated deprecated message.
FileLineInfoMap	_syntax_to_line

Detailed Description

Holding syntax for parsing input files.

Definition at line 21 of file Syntax.h.

Constructor & Destructor Documentation

Syntax()

Syntax::Syntax

(

)

Definition at line 17 of file Syntax.C.

: _actions_to_syntax_valid(false) {}

Member Function Documentation

addDependency()

void Syntax::addDependency	(	const std::string &	task,
		const std::string &	pre_req
	)

Definition at line 60 of file Syntax.C.

{
  if (_registered_tasks.find(task) == _registered_tasks.end())
    mooseError("A ", task, " is not a registered task name.");
 
  _tasks.insertDependency(task, pre_req);
}

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

addDependencySets()

void Syntax::addDependencySets

(

const std::string &

action_sets

)

Adds all dependencies in a single call.

The string is split on parenthesis and each task listed within the parenthesis is given equal precedence.

Definition at line 69 of file Syntax.C.

{
  std::vector<std::string> sets, prev_names, tasks;
  MooseUtils::tokenize(action_sets, sets, 1, "()");
 
  for (unsigned int i = 0; i < sets.size(); ++i)
  {
    tasks.clear();
    MooseUtils::tokenize(sets[i], tasks, 0, ", ");
    for (unsigned int j = 0; j < tasks.size(); ++j)
    {
      // Each line should depend on each item in the previous line
      for (unsigned int k = 0; k < prev_names.size(); ++k)
        addDependency(tasks[j], prev_names[k]);
    }
    // Copy the the current items to the previous items for the next iteration
    std::swap(tasks, prev_names);
  }
}

appendTaskName()

void Syntax::appendTaskName	(	const std::string &	task,
		const std::string &	moose_object_type,
		bool	deprecated
	)

Method to associate another "allowed" pluggable MOOSE system to an existing registered task.

Each object created during a task is checked against associated systems.

Parameters

task	the task to allow a new type of moose objects for
moose_object_type	the type of objects to allow with this task
deprecated	whether constructing this moose object with this task is deprecated

Definition at line 46 of file Syntax.C.

{
  if (_registered_tasks.find(task) == _registered_tasks.end())
    mooseError("A ", task, " is not a registered task name.");
 
  if (!deprecated)
    _moose_systems_to_tasks.insert(std::make_pair(moose_object_type, task));
  else
    _deprecated_list_moose_systems_to_tasks.insert(std::make_pair(moose_object_type, task));
}

clearTaskDependencies()

void Syntax::clearTaskDependencies

(

)

Clears all tasks from the system object.

Definition at line 99 of file Syntax.C.

{
  _tasks.clear();
}

deleteTaskDependencies()

void Syntax::deleteTaskDependencies

(

const std::string &

task

)

Deletes or removes the dependencies that this task depends on.

This method does not fixup or change the graph in any other way.

Definition at line 90 of file Syntax.C.

{
  if (_registered_tasks.find(task) == _registered_tasks.end())
    mooseError("A ", task, " is not a registered task name.");
 
  _tasks.deleteDependenciesOfKey(task);
}

deprecateActionSyntax() [1/2]

void Syntax::deprecateActionSyntax

(

const std::string &

syntax

)

This method deprecates previously registered syntax.

You should use the exact form that you want deprecated in the passed in parameter.

Definition at line 181 of file Syntax.C.

{
  const std::string message = "\"[" + syntax + "]\" is deprecated.";
  deprecateActionSyntax(syntax, message);
}

Referenced by deprecateActionSyntax().

deprecateActionSyntax() [2/2]

void Syntax::deprecateActionSyntax	(	const std::string &	syntax,
		const std::string &	message
	)

Definition at line 188 of file Syntax.C.

{
  _deprecated_syntax.insert(std::make_pair(syntax, message));
}

deprecatedActionSyntaxMessage()

std::string Syntax::deprecatedActionSyntaxMessage

(

const std::string

syntax

)

Returns the deprecation message for a given syntax that has been deprecated by deprecateActionSyntax.

Definition at line 194 of file Syntax.C.

{
  auto it = _deprecated_syntax.find(syntax);
 
  if (it != _deprecated_syntax.end())
    return it->second;
  else
    mooseError("The action syntax ", syntax, " is not deprecated");
}

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

getActions()

std::pair< std::multimap< std::string, Syntax::ActionInfo >::const_iterator, std::multimap< std::string, Syntax::ActionInfo >::const_iterator > Syntax::getActions

(

const std::string &

syntax

)

const

Returns a pair of multimap iterators to all the ActionInfo objects associated with a given piece of syntax.

Definition at line 329 of file Syntax.C.

{
  return _syntax_to_actions.equal_range(syntax);
}

Referenced by MooseServer::getActionParameters(), Moose::Builder::listValidParams(), and Moose::Builder::walkRaw().

getAssociatedActions()

const std::multimap< std::string, Syntax::ActionInfo > & Syntax::getAssociatedActions

(

)

const

Return all Syntax to Action associations.

Definition at line 375 of file Syntax.C.

{
  return _syntax_to_actions;
}

Referenced by MooseServer::addSubblocksToList(), Moose::Builder::buildFullTree(), Moose::Builder::buildJsonSyntaxTree(), and MooseApp::setupOptions().

getAssociatedTypes()

const std::multimap< std::string, std::string > & Syntax::getAssociatedTypes

(

)

const

Get a multimap of registered associations of syntax with type.

Definition at line 369 of file Syntax.C.

{
  return _associated_types;
}

Referenced by MooseServer::addValuesToList(), Moose::Builder::buildJsonSyntaxTree(), MooseServer::gatherDocumentReferencesLocations(), MooseServer::getCompletionItemKind(), and MooseServer::getInputLookupDefinitionNodes().

getLineInfo()

FileLineInfo Syntax::getLineInfo	(	const std::string &	syntax,
		const std::string &	action,
		const std::string &	task
	)		const

Gets the file and line where the syntax/action/task combo was registered.

Parameters

syntax	Syntax name
action	Action name
task	Task name

Returns

A FileLineInfo associated with the syntax/action/task triplet

Definition at line 381 of file Syntax.C.

{
  return _syntax_to_line.getInfo(syntax, action, task);
}

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

getNonDeprecatedSyntaxByAction()

std::vector< std::string > Syntax::getNonDeprecatedSyntaxByAction	(	const std::string &	action,
		const std::string &	task = ""
	)

Retrieve the non-deprecated syntax associated with the passed in action type string.

If a task string is also passed in, only syntax associated with that action+task combo will be returned.

Definition at line 238 of file Syntax.C.

{
  auto syntaxes = getSyntaxByAction(action, task);
  for (auto syntax_it = begin(syntaxes); syntax_it != end(syntaxes);)
  {
    if (isDeprecatedSyntax(*syntax_it))
      syntax_it = syntaxes.erase(syntax_it);
    else
      ++syntax_it;
  }
  return syntaxes;
}

Referenced by ActionWarehouse::addActionBlock().

getSortedTask()

const std::vector< std::string > & Syntax::getSortedTask

(

)

Get a list of serialized tasks in a correct dependency order.

The order my be more ordered than specified.

Definition at line 105 of file Syntax.C.

{
  try
  {
    return _tasks.getSortedValues();
  }
  catch (CyclicDependencyException<std::string> & e)
  {
    const auto & cycle = e.getCyclicDependencies();
    mooseError("Cyclic dependencies detected: ", MooseUtils::join(cycle, " <- "));
  }
}

Referenced by ActionWarehouse::build().

getSortedTaskSet()

const std::vector< std::vector< std::string > > & Syntax::getSortedTaskSet

(

)

Get a list of serialized tasks in a correct dependency order.

The vector of sets return type assures that tasks with equal precedence appear in a single set.

Definition at line 119 of file Syntax.C.

{
  return _tasks.getSortedValuesSets();
}

Referenced by ActionWarehouse::printActionDependencySets().

getSyntaxByAction()

std::vector< std::string > Syntax::getSyntaxByAction	(	const std::string &	action,
		const std::string &	task = ""
	)

Retrieve the syntax associated with the passed in action type string.

If a task string is also passed in, only syntax associated with that action+task combo will be returned.

Definition at line 211 of file Syntax.C.

{
  // See if the reverse multimap has been built yet, if not build it now
  if (!_actions_to_syntax_valid)
  {
    std::transform(_syntax_to_actions.begin(),
                   _syntax_to_actions.end(),
                   std::inserter(_actions_to_syntax, _actions_to_syntax.begin()),
                   [](const std::pair<std::string, ActionInfo> pair)
                   {
                     return std::make_pair(pair.second._action,
                                           std::make_pair(pair.first, pair.second._task));
                   });
    _actions_to_syntax_valid = true;
  }
 
  std::vector<std::string> syntax;
  auto it_pair = _actions_to_syntax.equal_range(action);
  for (const auto & syntax_pair : as_range(it_pair))
    // If task is blank, return all syntax, otherwise filter by task
    if (task == "" || syntax_pair.second.second == task)
      syntax.emplace_back(syntax_pair.second.first);
 
  return syntax;
}

Referenced by Moose::Builder::build(), getNonDeprecatedSyntaxByAction(), and Moose::Builder::queryGlobalParamsNode().

hasTask()

bool Syntax::hasTask

(

const std::string &

task

)

const

Returns a Boolean indicating whether or not a task is registered with the syntax object.

Definition at line 125 of file Syntax.C.

{
  return (_registered_tasks.find(task) != _registered_tasks.end());
}

Referenced by ActionWarehouse::addActionBlock(), and ActionWarehouse::setFinalTask().

isActionRequired()

bool Syntax::isActionRequired

(

const std::string &

task

)

const

Returns a Boolean indicating whether the specified task is required.

DEPRECATED (use shouldAutoBuild).

Definition at line 131 of file Syntax.C.

{
  mooseDeprecated("Syntax::isActionRequired is deprecated, use shouldAutoBuild() instead");
  return shouldAutoBuild(task);
}

isAssociated()

std::string Syntax::isAssociated	(	const std::string &	real_id,
		bool *	is_parent,
		const std::map< std::string, std::set< std::string > > &	alt_map = {}
	)		const

Method for determining whether a piece of syntax is associated with an Action an optional syntax map may be given to traverse instead of _syntax_to_actions TODO: I need a better name.

This implementation assumes that wildcards can occur in the place of an entire token but not as part of a token (i.e. 'Variables/ * /InitialConditions' is valid but not 'Variables/Partial* /InitialConditions'. Since maps are ordered, a reverse traversal through the registered list will always select a more specific match before a wildcard match ('*' == char(42)).

Definition at line 252 of file Syntax.C.

{
  // if non-empty alt_map was provided then traverse its syntax instead of _syntax_to_actions
  std::set<std::string> syntax_to_traverse;
  if (!alt_map.empty())
    std::transform(alt_map.begin(),
                   alt_map.end(),
                   std::inserter(syntax_to_traverse, syntax_to_traverse.end()),
                   [](auto pair) { return pair.first; });
  else
    std::transform(_syntax_to_actions.begin(),
                   _syntax_to_actions.end(),
                   std::inserter(syntax_to_traverse, syntax_to_traverse.end()),
                   [](auto pair) { return pair.first; });
 
  bool local_is_parent;
  if (is_parent == nullptr)
    is_parent = &local_is_parent; // Just so we don't have to keep checking below when we want to
                                  // set the value
  std::vector<std::string> real_elements, reg_elements;
  std::string return_value;
 
  MooseUtils::tokenize(real_id, real_elements);
 
  *is_parent = false;
  for (auto it = syntax_to_traverse.rbegin(); it != syntax_to_traverse.rend(); ++it)
  {
    std::string reg_id = *it;
    if (reg_id == real_id)
    {
      *is_parent = false;
      return reg_id;
    }
    reg_elements.clear();
    MooseUtils::tokenize(reg_id, reg_elements);
    if (real_elements.size() <= reg_elements.size())
    {
      bool keep_going = true;
      for (unsigned int j = 0; keep_going && j < real_elements.size(); ++j)
      {
        if (real_elements[j] != reg_elements[j] && reg_elements[j] != std::string("*"))
          keep_going = false;
      }
      if (keep_going)
      {
        if (real_elements.size() < reg_elements.size() && !*is_parent)
        {
          // We found a parent, the longest parent in fact but we need to keep
          // looking to make sure that the real thing isn't registered
          *is_parent = true;
          return_value = reg_id;
        }
        else if (real_elements.size() == reg_elements.size())
        {
          *is_parent = false;
          return reg_id;
        }
      }
    }
  }
 
  if (*is_parent)
    return return_value;
  else
    return "";
}

Referenced by MooseServer::addSubblocksToList(), MooseServer::gatherDocumentReferencesLocations(), MooseServer::getActionParameters(), Moose::Builder::listValidParams(), ActionWarehouse::printInputFile(), and Moose::Builder::walkRaw().

isDeprecatedSyntax()

bool Syntax::isDeprecatedSyntax

(

const std::string &

syntax

)

const

Returns a Boolean indicating whether the syntax has been deprecated through a call to deprecateActionSyntax.

Definition at line 205 of file Syntax.C.

{
  return _deprecated_syntax.find(syntax) != _deprecated_syntax.end();
}

Referenced by getNonDeprecatedSyntaxByAction(), and Moose::Builder::walkRaw().

registerActionSyntax()

void Syntax::registerActionSyntax	(	const std::string &	action,
		const std::string &	syntax,
		const std::string &	task = "",
		const std::string &	file = "",
		int	line = -1
	)

Registration function for associating Moose Actions with syntax.

Definition at line 147 of file Syntax.C.

{
  auto range = _syntax_to_actions.equal_range(syntax);
  for (auto it = range.first; it != range.second; ++it)
    if (it->second._action == action && it->second._task == task)
      return;
 
  _syntax_to_actions.insert(std::make_pair(syntax, ActionInfo{action, task}));
  _syntax_to_line.addInfo(syntax, action, task, file, line);
  _actions_to_syntax_valid = false;
}

Referenced by replaceActionSyntax().

registerSyntaxType()

void Syntax::registerSyntaxType	(	const std::string &	syntax,
		const std::string &	type
	)

Register a type with a block.

For example, associate FunctionName with the Functions block.

Parameters

syntax	The target syntax to associate the type with
type	The name of the type to associate with the syntax

Definition at line 363 of file Syntax.C.

{
  _associated_types.insert(std::make_pair(syntax, type));
}

registerTaskName() [1/2]

void Syntax::registerTaskName	(	const std::string &	task,
		bool	should_auto_build = false
	)

Method to register a new task.

Tasks are short verbs (strings) that describe a particular point in the simulation setup phase.

Parameters

task	The task (verb) to be registered with MOOSE.
should_autobuild	indicates whether the task should be autobuilt if not supplied elsewhere.

Definition at line 20 of file Syntax.C.

{
  if (_registered_tasks.count(task) > 0)
    return;
  _tasks.addItem(task);
  _registered_tasks[task] = should_auto_build;
}

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

registerTaskName() [2/2]

void Syntax::registerTaskName	(	const std::string &	task,
		const std::string &	moose_object_type,
		bool	should_auto_build = false
	)

Method to register a new task (see overload method with same name).

This version also accepts a string representing a pluggable MOOSE system. When objects are created through a task, the MOOSE system is checked if it exists to make sure it's "allowed" to create those types of objects.

Definition at line 29 of file Syntax.C.

{
  auto range = _moose_systems_to_tasks.equal_range(moose_object_type);
  for (auto it = range.first; it != range.second; ++it)
    if (it->second == task)
      return;
 
  if (_registered_tasks.find(task) != _registered_tasks.end())
    mooseError("A ", task, " is already registered.  Do you need to use appendTaskName instead?");
 
  registerTaskName(task, should_auto_build);
  _moose_systems_to_tasks.insert(std::make_pair(moose_object_type, task));
}

removeAllActionsForSyntax()

void Syntax::removeAllActionsForSyntax

(

const std::string &

syntax

)

De-registers all actions associated with a given syntax.

Definition at line 175 of file Syntax.C.

{
  _syntax_to_actions.erase(syntax);
}

replaceActionSyntax()

void Syntax::replaceActionSyntax	(	const std::string &	action,
		const std::string &	syntax,
		const std::string &	task,
		const std::string &	file = "",
		int	line = -1
	)

Registration function that replaces existing Moose Actions with a completely new action Note: This function will remove all actions associated with this piece of syntax NOT just a single match of some kind.

Definition at line 164 of file Syntax.C.

{
  _syntax_to_actions.erase(syntax);
  registerActionSyntax(action, syntax, task, file, line);
}

shouldAutoBuild()

bool Syntax::shouldAutoBuild

(

const std::string &

task

)

const

Returns a Boolean indicating whether MOOSE should attempt to automatically create an Action to satisfy a task if an Action doesn't already exist to service that task.

Definition at line 138 of file Syntax.C.

{
  auto map_pair = _registered_tasks.find(task);
  mooseAssert(map_pair != _registered_tasks.end(), std::string("Unregistered task: ") + task);
 
  return map_pair->second;
}

Referenced by ActionWarehouse::buildBuildableActions(), and isActionRequired().

verifyMooseObjectTask()

bool Syntax::verifyMooseObjectTask	(	const std::string &	base,
		const std::string &	task
	)		const

Returns a Boolean indicating whether a task is associated with on of the MOOSE pluggable systems (BASE CLASSES).

See "registerMooseObjectTask" macro in Moose.C. This information can be used to determine whether certain objects may be safely built during the specified task.

Definition at line 335 of file Syntax.C.

{
  auto iters = _moose_systems_to_tasks.equal_range(base);
 
  for (const auto & task_it : as_range(iters))
    if (task == task_it.second)
      return true;
 
  iters = _deprecated_list_moose_systems_to_tasks.equal_range(base);
  for (const auto & task_it : as_range(iters))
    if (task == task_it.second)
    {
      std::string object_tasks = "";
      for (const auto & other_task : as_range(_moose_systems_to_tasks.equal_range(base)))
        object_tasks += (object_tasks == "" ? "" : " ") + other_task.second;
 
      mooseDeprecated(
          "Adding objects from system '" + base + "' through task '" + task +
          "' is deprecated. This object should only be added from task(s): " + object_tasks +
          ". This is likely caused by adding objects in a block they no longer belong to. For "
          "example, FunctorMaterials should no longer be added in the [Materials] block.");
      return true;
    }
 
  return false;
}

Referenced by ActionWarehouse::addActionBlock(), MooseServer::addValuesToList(), Moose::Builder::buildFullTree(), Moose::Builder::buildJsonSyntaxTree(), MooseServer::getHoverDisplayText(), and MooseServer::getObjectParameters().

Member Data Documentation

_actions_to_syntax

std::multimap<std::string, std::pair<std::string, std::string> > Syntax::_actions_to_syntax

protected

The ActionInfo (Action+task) to syntax associations (built only when needed) Action -> (Syntax, Task)

Definition at line 239 of file Syntax.h.

Referenced by getSyntaxByAction().

_actions_to_syntax_valid

bool Syntax::_actions_to_syntax_valid

protected

Boolean indicating whether the _actions_to_syntax map is built and valid and synced.

Definition at line 245 of file Syntax.h.

Referenced by getSyntaxByAction(), and registerActionSyntax().

_associated_types

std::multimap<std::string, std::string> Syntax::_associated_types

protected

Syntax/Type association.

Definition at line 242 of file Syntax.h.

Referenced by getAssociatedTypes(), and registerSyntaxType().

_deprecated_list_moose_systems_to_tasks

std::multimap<std::string, std::string> Syntax::_deprecated_list_moose_systems_to_tasks

protected

A list of Moose system objects to tasks that are deprecated for these systems.

If an item is in this map, the task is still allowed to build the object from the MOOSE system, but it is deprecated to do so.

Definition at line 229 of file Syntax.h.

Referenced by appendTaskName(), and verifyMooseObjectTask().

_deprecated_syntax

std::map<std::string, std::string> Syntax::_deprecated_syntax

protected

The list of deprecated syntax items and the associated deprecated message.

Definition at line 248 of file Syntax.h.

Referenced by deprecateActionSyntax(), deprecatedActionSyntaxMessage(), and isDeprecatedSyntax().

_moose_systems_to_tasks

std::multimap<std::string, std::string> Syntax::_moose_systems_to_tasks

protected

The list of Moose system objects to tasks. This map indicates which tasks are allowed to build certain MooseObjects.

Definition at line 224 of file Syntax.h.

Referenced by appendTaskName(), registerTaskName(), and verifyMooseObjectTask().

_registered_tasks

std::map<std::string, bool> Syntax::_registered_tasks

protected

The list of registered tasks and a flag indicating whether or not they should be auto-built.

Definition at line 221 of file Syntax.h.

Referenced by addDependency(), appendTaskName(), deleteTaskDependencies(), hasTask(), registerTaskName(), registerTaskName(), and shouldAutoBuild().

_syntax_to_actions

std::multimap<std::string, ActionInfo> Syntax::_syntax_to_actions

protected

The syntax object to ActionInfo (Action+task) associations.

Definition at line 235 of file Syntax.h.

Referenced by getActions(), getAssociatedActions(), getSyntaxByAction(), isAssociated(), registerActionSyntax(), removeAllActionsForSyntax(), and replaceActionSyntax().

_syntax_to_line

FileLineInfoMap Syntax::_syntax_to_line

protected

Definition at line 250 of file Syntax.h.

Referenced by getLineInfo(), and registerActionSyntax().

_tasks

DependencyResolver<std::string> Syntax::_tasks

protected

The dependency resolver.

Definition at line 232 of file Syntax.h.

Referenced by addDependency(), clearTaskDependencies(), deleteTaskDependencies(), getSortedTask(), getSortedTaskSet(), and registerTaskName().

---

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

• include/parser/Syntax.h
• src/parser/Syntax.C