Registry Class Reference

The registry is used as a global singleton to collect information on all available MooseObject and Action classes for use in a moose app/simulation. More...

#include <Registry.h>

Static Public Member Functions
template<typename T >
static char	add (const RegistryEntry &info)
	Adds information on a MooseObject to the registry. More...
template<typename T >
static char	addAction (const RegistryEntry &info)
	Adds information on an Action object to the registry. More...
static void	registerObjectsTo (Factory &f, const std::set< std::string > &labels)
	This registers all MooseObjects known to the registry that have the given label(s) with the factory f. More...
static void	registerActionsTo (ActionFactory &f, const std::set< std::string > &labels)
	This registers all Actions known to the registry that have the given label(s) with the factory f. More...
static void	checkLabels (const std::set< std::string > &known_labels={})
	This runs error checking to make sure that all objects and actions in the registry have valid labels. More...
static char	addKnownLabel (const std::string &label)
	addKnownLabel whitelists a label as valid for purposes of the checkLabels function. More...
static const std::map< std::string, std::vector< RegistryEntry > > &	allObjects ()
	Returns a per-label keyed map of all MooseObjects in the registry. More...
static const std::map< std::string, std::vector< RegistryEntry > > &	allActions ()
	Returns a per-label keyed map of all Actions in the registry. More...

Static Private Member Functions
static void	addInner (const RegistryEntry &info)
static void	addActionInner (const RegistryEntry &info)

Private Attributes
std::map< std::string, std::vector< RegistryEntry > >	_per_label_objects
std::map< std::string, std::vector< RegistryEntry > >	_per_label_actions
std::set< std::string >	_known_labels

Detailed Description

The registry is used as a global singleton to collect information on all available MooseObject and Action classes for use in a moose app/simulation.

It must be global because we want+need to be able to register objects in global scope during static initialization time before other parts of the moose app execution have started running. This allows us to distribute registration across all the files that define the actual classes being registered so we don't have to have any central location with a bajillion includes that makes (especially incremental) compiles slow. The registry collects the app, name, and other information for each objects and makes it available to the moose object and action factories and others for general use. All public functions in this class modify and return data from the global singleton.

Definition at line 180 of file Registry.h.

Member Function Documentation

add()

template<typename T >

static char Registry::add ( const RegistryEntry &  info )

inlinestatic

Adds information on a MooseObject to the registry.

The _build_ptr, _build_action_ptr, and _params_ptr objects of the info object should all be nullptr - these are set automatically by the add function itself using the templated type T.

Definition at line 187 of file Registry.h.

  {
    RegistryEntry copy = info;
    copy._build_ptr = &buildObj<T>;
    copy._params_ptr = &validParams<T>;
    addInner(copy);
    return 0;
  }

addAction()

template<typename T >

static char Registry::addAction ( const RegistryEntry &  info )

inlinestatic

Adds information on an Action object to the registry.

The _build_ptr, _build_action_ptr, and _params_ptr objects of the info object should all be nullptr - these are set automatically by the addAction function itself using the templated type T.

Definition at line 200 of file Registry.h.

  {
    RegistryEntry copy = info;
    copy._build_action_ptr = &buildAct<T>;
    copy._params_ptr = &validParams<T>;
    addActionInner(copy);
    return 0;
  }

addActionInner()

void Registry::addActionInner ( const RegistryEntry &  info )

staticprivate

Definition at line 45 of file Registry.C.

Referenced by addAction().

{
  auto & r = getRegistry();
  r._per_label_actions[info._label].push_back(info);
}

addInner()

void Registry::addInner ( const RegistryEntry &  info )

staticprivate

Definition at line 38 of file Registry.C.

Referenced by add().

{
  auto & r = getRegistry();
  r._per_label_objects[info._label].push_back(info);
}

addKnownLabel()

char Registry::addKnownLabel ( const std::string &  label )

static

addKnownLabel whitelists a label as valid for purposes of the checkLabels function.

Definition at line 124 of file Registry.C.

Referenced by MooseApp::MooseApp().

{
  auto & r = getRegistry();
  r._known_labels.insert(label);
  return 0;
}

allActions()

const std::map< std::string, std::vector< RegistryEntry > > & Registry::allActions ( )

static

Returns a per-label keyed map of all Actions in the registry.

Definition at line 32 of file Registry.C.

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

{
  return getRegistry()._per_label_actions;
}

allObjects()

const std::map< std::string, std::vector< RegistryEntry > > & Registry::allObjects ( )

static

Returns a per-label keyed map of all MooseObjects in the registry.

Definition at line 27 of file Registry.C.

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

{
  return getRegistry()._per_label_objects;
}

checkLabels()

void Registry::checkLabels ( const std::set< std::string > &  known_labels = {} )

static

This runs error checking to make sure that all objects and actions in the registry have valid labels.

Labels are considered valid if they have been added to the list of known labels via the addKnownLabel function or they have been used to register objects to a factory via registerObjectsTo or registerActionsTo.

Definition at line 101 of file Registry.C.

Referenced by MooseApp::checkRegistryLabels().

{
  auto & r = getRegistry();
  std::vector<RegistryEntry> orphs;

  for (auto & entry : r._per_label_objects)
    if (known_labels.count(entry.first) == 0 && r._known_labels.count(entry.first) == 0)
      orphs.insert(orphs.end(), entry.second.begin(), entry.second.end());
  for (auto & entry : r._per_label_actions)
    if (known_labels.count(entry.first) == 0 && r._known_labels.count(entry.first) == 0)
      orphs.insert(orphs.end(), entry.second.begin(), entry.second.end());

  if (orphs.size() > 0)
  {
    std::stringstream lst;
    for (auto & orph : orphs)
      lst << "\n\t" << orph._classname << " (app='" << orph._label << "')";
    mooseError("The following objects/actions have been registered to unknown applications/labels:",
               lst.str());
  }
}

registerActionsTo()

void Registry::registerActionsTo ( ActionFactory &  f, const std::set< std::string > &  labels  )

static

This registers all Actions known to the registry that have the given label(s) with the factory f.

Definition at line 85 of file Registry.C.

Referenced by Moose::registerActions().

{
  auto & r = getRegistry();
  for (const auto & label : labels)
  {
    r._known_labels.insert(label);
    if (r._per_label_actions.count(label) == 0)
      continue;

    for (const auto & obj : r._per_label_actions[label])
      f.reg(
          obj._classname, obj._name, obj._build_action_ptr, obj._params_ptr, obj._file, obj._line);
  }
}

registerObjectsTo()

void Registry::registerObjectsTo ( Factory &  f, const std::set< std::string > &  labels  )

static

This registers all MooseObjects known to the registry that have the given label(s) with the factory f.

Definition at line 52 of file Registry.C.

Referenced by Moose::registerObjects().

{
  auto & r = getRegistry();
  for (const auto & label : labels)
  {
    r._known_labels.insert(label);
    if (r._per_label_objects.count(label) == 0)
      continue;

    for (const auto & obj : r._per_label_objects[label])
    {
      std::string name = obj._name;
      if (name.empty())
        name = obj._alias;
      if (name.empty())
        name = obj._classname;

      f.reg(obj._label,
            name,
            obj._build_ptr,
            obj._params_ptr,
            obj._deprecated_time,
            obj._replaced_by,
            obj._file,
            obj._line);

      if (!obj._alias.empty())
        f.associateNameToClass(name, obj._classname);
    }
  }
}

Member Data Documentation

_known_labels

std::set<std::string> Registry::_known_labels

private

Definition at line 237 of file Registry.h.

_per_label_actions

std::map<std::string, std::vector<RegistryEntry> > Registry::_per_label_actions

private

Definition at line 236 of file Registry.h.

Referenced by allActions().

_per_label_objects

std::map<std::string, std::vector<RegistryEntry> > Registry::_per_label_objects

private

Definition at line 235 of file Registry.h.

Referenced by allObjects().

---

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

• include/base/Registry.h
• src/base/Registry.C