Consolidate register

framework/include/actions/ActionFactory.h

@@ -133,6 +133,9 @@ class ActionFactory
 
   FileLineInfoMap _name_to_line;
   std::multimap<std::string, std::string> _task_to_action_map;
+
+  /// set<objectname, task> used to track if an object previously added is being added again
+  std::set<std::pair<std::string, std::string>> _current_objs;
 };
 
 #endif /* ACTIONFACTORY_H */

framework/include/base/Moose.h

@@ -163,6 +163,8 @@ using libMesh::out;
  * Register objects that are in MOOSE
  */
 
+void registerAll(Factory & f, ActionFactory & af, Syntax & s);
+
 void registerObjects(Factory & factory);
 void registerObjects(Factory & factory, const std::set<std::string> & obj_labels);
 void addActionTypes(Syntax & syntax);
@@ -172,6 +174,8 @@ void registerActions(Syntax & syntax,
                      const std::set<std::string> & obj_labels);
 void registerExecFlags(Factory & factory);
 
+void associateSyntax(Syntax & syntax, ActionFactory & action_factory);
+
 void setSolverDefaults(FEProblemBase & problem);
 
 /**

framework/include/base/MooseApp.h

@@ -415,18 +415,15 @@ class MooseApp : public ConsoleStreamInterface, public libMesh::ParallelObject
    * attempts to load a dynamic library and register it when it is needed. Throws an error if
    * no suitable library is found that contains the app_name in question.
    */
-  void dynamicObjectRegistration(const std::string & app_name,
-                                 Factory * factory,
-                                 std::string library_path,
-                                 const std::string & library_name);
+  void dynamicAllRegistration(const std::string & app_name,
+                              Factory * factory,
+                              ActionFactory * action_factory,
+                              Syntax * syntax,
+                              std::string library_path,
+                              const std::string & library_name);
   void dynamicAppRegistration(const std::string & app_name,
                               std::string library_path,
                               const std::string & library_name);
-  void dynamicSyntaxAssociation(const std::string & app_name,
-                                Syntax * syntax,
-                                ActionFactory * action_factory,
-                                std::string library_path,
-                                const std::string & library_name);
   ///@}
 
   /**
@@ -791,8 +788,7 @@ class MooseApp : public ConsoleStreamInterface, public libMesh::ParallelObject
   enum RegistrationType
   {
     APPLICATION,
-    OBJECT,
-    SYNTAX
+    REGALL
   };
 
   /// Level of multiapp, the master is level 0. This used by the Console to indent output

framework/include/parser/MooseSyntax.h

@@ -10,12 +10,4 @@
 #ifndef MOOSESYNTAX_H
 #define MOOSESYNTAX_H
 
-class Syntax;
-class ActionFactory;
-
-namespace Moose
-{
-void associateSyntax(Syntax & syntax, ActionFactory & action_factory);
-}
-
 #endif // MOOSESYNTAX_H

framework/include/utils/DependencyResolver.h

@@ -127,8 +127,11 @@ class DependencyResolver
   /// This is our main data structure a multimap that contains any number of dependencies in a key = value format
   std::multimap<T, T> _depends;
 
+  /// Used to avoid duplicate tracking of identical insertions of dependencies
+  std::set<std::pair<T, T>> _unique_deps;
+
   /// Extra items that need to come out in the sorted list but contain no dependencies
-  std::vector<T> _independent_items;
+  std::set<T> _independent_items;
 
   // A vector retaining the order in which items were added to the
   // resolver, to disambiguate ordering of items with no
@@ -204,6 +207,11 @@ template <typename T>
 void
 DependencyResolver<T>::insertDependency(const T & key, const T & value)
 {
+  auto k = std::make_pair(key, value);
+  if (_unique_deps.count(k) > 0)
+    return;
+  _unique_deps.insert(k);
+
   if (dependsOn(value, key))
   {
     throw CyclicDependencyException<T>(
@@ -220,7 +228,7 @@ template <typename T>
 void
 DependencyResolver<T>::addItem(const T & value)
 {
-  _independent_items.push_back(value);
+  _independent_items.insert(value);
   if (std::find(_ordering_vector.begin(), _ordering_vector.end(), value) == _ordering_vector.end())
     _ordering_vector.push_back(value);
 }
@@ -295,7 +303,7 @@ DependencyResolver<T>::getSortedValuesSets()
   _ordered_items.clear();
 
   // Put the independent items into the first set in _ordered_items
-  std::vector<T> next_set(_independent_items);
+  std::vector<T> next_set(_independent_items.begin(), _independent_items.end());
 
   /* Topological Sort */
   while (!depends.empty())

framework/include/utils/MooseEnumItem.h

@@ -72,7 +72,10 @@ class MooseEnumItem
   /**
    * Less than operator. This is required for this class to work in maps and sets.
    */
-  bool operator<(const MooseEnumItem & other) const { return _id < other._id; }
+  bool operator<(const MooseEnumItem & other) const
+  {
+    return _id != other._id ? _id < other._id : _name < other._name;
+  }
 
   /**
    * ostream operator for string printing.

framework/src/actions/ActionFactory.C

@@ -23,6 +23,11 @@ ActionFactory::reg(const std::string & name,
                    const std::string & file,
                    int line)
 {
+  auto key = std::make_pair(name, task);
+  if (_current_objs.count(key) > 0)
+    return;
+  _current_objs.insert(key);
+
   BuildInfo build_info;
   build_info._build_pointer = obj_builder;
   build_info._params_pointer = ref_params;

framework/src/actions/DynamicObjectRegistrationAction.C

@@ -55,15 +55,12 @@ DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(InputParameters
         getParam<std::vector<std::string>>("register_objects_from");
     for (const auto & app_name : application_names)
     {
-      _app.dynamicObjectRegistration(app_name,
-                                     &_factory,
-                                     getParam<std::string>("library_path"),
-                                     getParam<std::string>("library_name"));
-      _app.dynamicSyntaxAssociation(app_name,
-                                    &_awh.syntax(),
-                                    &_action_factory,
-                                    getParam<std::string>("library_path"),
-                                    getParam<std::string>("library_name"));
+      _app.dynamicAllRegistration(app_name,
+                                  &_factory,
+                                  &_action_factory,
+                                  &_awh.syntax(),
+                                  getParam<std::string>("library_path"),
+                                  getParam<std::string>("library_name"));
     }
   }
 }

framework/src/base/Moose.C

@@ -19,6 +19,7 @@
 #include "Factory.h"
 #include "PetscSupport.h"
 #include "Syntax.h"
+#include "MooseSyntax.h"
 
 #include <unistd.h>
 
@@ -43,9 +44,21 @@ const ExecFlagType EXEC_SAME_AS_MULTIAPP("SAME_AS_MULTIAPP");
 namespace Moose
 {
 
+void associateSyntaxInner(Syntax & syntax, ActionFactory & action_factory);
+
+void
+registerAll(Factory & f, ActionFactory & af, Syntax & s)
+{
+  registerObjects(f, {"MooseApp"});
+  associateSyntaxInner(s, af);
+  registerActions(s, af, {"MooseApp"});
+  registerExecFlags(f);
+}
+
 void
 registerObjects(Factory & factory)
 {
+  mooseDeprecated("use registerAll instead of registerObjects");
   registerObjects(factory, {"MooseApp"});
 }
 
@@ -302,6 +315,7 @@ addActionTypes(Syntax & syntax)
 void
 registerActions(Syntax & syntax, ActionFactory & action_factory)
 {
+  mooseDeprecated("use registerAll instead of registerActions");
   registerActions(syntax, action_factory, {"MooseApp"});
 }
 
@@ -333,6 +347,159 @@ registerExecFlags(Factory & factory)
   registerExecFlag(EXEC_SAME_AS_MULTIAPP);
 }
 
+void
+associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
+{
+  /**
+   * Note: the optional third parameter is used to differentiate which task is
+   * satisfied based on the syntax encountered for classes which are registered
+   * to satisfy more than one task
+   */
+  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
+  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
+  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
+  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
+
+  registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
+  registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
+  registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
+  registerSyntaxTask("AddKernelAction", "Bounds/*", "add_aux_kernel");
+
+  registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
+  registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
+
+  registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
+
+  registerSyntax("CreateProblemAction", "Problem");
+  registerSyntax("DynamicObjectRegistrationAction", "Problem");
+  registerSyntax("SetupMeshAction", "Mesh");
+  registerSyntax("SetupMeshCompleteAction", "Mesh");
+  //  registerSyntaxTask("SetupMeshCompleteAction", "Mesh", "prepare_mesh");
+  //  registerSyntaxTask("SetupMeshCompleteAction", "Mesh", "setup_mesh_complete");
+  registerSyntax("CreateDisplacedProblemAction", "Mesh");
+  registerSyntax("AddMeshModifierAction", "MeshModifiers/*");
+  registerSyntax("AddMortarInterfaceAction", "Mesh/MortarInterfaces/*");
+
+  registerSyntax("AddFunctionAction", "Functions/*");
+  syntax.registerSyntaxType("Functions/*", "FunctionName");
+
+  registerSyntax("GlobalParamsAction", "GlobalParams");
+
+  registerSyntax("AddDistributionAction", "Distributions/*");
+  registerSyntax("AddSamplerAction", "Samplers/*");
+
+  registerSyntax("SetupDebugAction", "Debug");
+  registerSyntax("SetupResidualDebugAction", "Debug");
+
+  /// Variable/AuxVariable Actions
+  registerSyntax("AddVariableAction", "Variables/*");
+  syntax.registerSyntaxType("Variables/*", "VariableName");
+  syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
+  //  syntax.registerActionSyntax("AddVariableAction", "Variables/*", "add_variable");
+  //  syntax.registerActionSyntax("AddVariableAction", "Variables/*", "add_ic");
+
+  registerSyntax("AddICAction", "Variables/*/InitialCondition");
+
+  registerSyntax("AddAuxVariableAction", "AuxVariables/*");
+  syntax.registerSyntaxType("AuxVariables/*", "VariableName");
+  syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
+  //  syntax.registerActionSyntax("AddAuxVariableAction", "AuxVariables/*", "add_aux_variable");
+  //  syntax.registerActionSyntax("AddAuxVariableAction", "AuxVariables/*", "add_ic");
+
+  registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
+
+  registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
+  registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
+
+  registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
+
+  registerSyntax("AddMaterialAction", "Materials/*");
+
+  registerSyntax("SetupPostprocessorDataAction", "Postprocessors/*");
+  registerSyntax("AddPostprocessorAction", "Postprocessors/*");
+  syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
+  syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
+
+  registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
+  syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
+
+  registerSyntax("AddDamperAction", "Dampers/*");
+
+  registerSyntax("AddOutputAction", "Outputs/*");
+  registerSyntax("CommonOutputAction", "Outputs");
+  syntax.registerSyntaxType("Outputs/*", "OutputName");
+
+  // Note: Preconditioner Actions will be built by this setup action
+  registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
+  registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
+
+  registerSyntax("CreateExecutionerAction", "Executioner");
+  registerSyntax("SetupTimeStepperAction", "Executioner/TimeStepper");
+  registerSyntax("SetupTimeIntegratorAction", "Executioner/TimeIntegrator");
+
+  registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
+  registerSyntax("SetupPredictorAction", "Executioner/Predictor");
+#ifdef LIBMESH_ENABLE_AMR
+  registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
+#endif
+
+  registerSyntax("PartitionerAction", "Mesh/Partitioner");
+
+  registerSyntax("AddDiracKernelAction", "DiracKernels/*");
+
+  registerSyntax("AddDGKernelAction", "DGKernels/*");
+
+  registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
+
+  registerSyntax("AddConstraintAction", "Constraints/*");
+
+  registerSyntax("AddUserObjectAction", "UserObjects/*");
+  syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
+  registerSyntax("AddControlAction", "Controls/*");
+  registerSyntax("AddBoundsVectorsAction", "Bounds");
+
+  registerSyntax("AddNodalNormalsAction", "NodalNormals");
+  //  registerSyntaxTask("AddNodalNormalsAction", "NodalNormals", "add_aux_variable");
+  //  registerSyntaxTask("AddNodalNormalsAction", "NodalNormals", "add_postprocessor");
+  //  registerSyntaxTask("AddNodalNormalsAction", "NodalNormals", "add_user_object");
+
+  // Indicator
+  registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
+  registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
+  syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
+
+  // Marker
+  registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
+  registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
+  syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
+
+  // New Adaptivity System
+  registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
+
+  // Deprecated Block
+  registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
+
+  // Multi Apps
+  registerSyntax("AddMultiAppAction", "MultiApps/*");
+  syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
+
+  // Transfers
+  registerSyntax("AddTransferAction", "Transfers/*");
+
+  // Material derivative test
+  registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
+  registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
+
+  addActionTypes(syntax);
+}
+
+void
+associateSyntax(Syntax & syntax, ActionFactory & action_factory)
+{
+  associateSyntaxInner(syntax, action_factory);
+  registerActions(syntax, action_factory);
+}
+
 void
 setSolverDefaults(FEProblemBase & problem)
 {