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>

Public Member Functions
	Registry (Registry const &)=delete
	Don't allow creation through copy/move construction or assignment. More...
Registry &	operator= (Registry const &)=delete
	Registry (Registry &&)=delete
Registry &	operator= (Registry &&)=delete

Static Public Member Functions
static Registry &	getRegistry ()
	Get the global Registry singleton. More...
template<typename T >
static char	add (const RegistryEntryData &base_info)
	Adds information on a MooseObject to the registry. More...
template<typename T >
static char	addAction (const RegistryEntryData &base_info)
	Adds information on an Action object to the registry. More...
template<typename T >
static std::string	getClassName ()
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 char	addKnownLabel (const std::string &label)
	addKnownLabel whitelists a label as valid for purposes of the checkLabels function. More...
static void	addDataFilePath (const std::string &name, const std::string &in_tree_path)
	register general search paths (folder name must be data) More...
static void	addAppDataFilePath (const std::string &app_name, const std::string &app_path)
	register search paths for an application (path determined relative to app_path); app_path should be passed as FILE from the application source file More...
static void	addDeprecatedAppDataFilePath (const std::string &app_path)
	deprecated method; use addAppDataFilePath instead More...
static void	addRepository (const std::string &repo_name, const std::string &repo_url)
	register a repository More...
static const std::map< std::string, std::vector< std::shared_ptr< RegistryEntryBase > > > &	allObjects ()
	Returns a per-label keyed map of all MooseObjects in the registry. More...
static const std::map< std::string, std::vector< std::shared_ptr< RegistryEntryBase > > > &	allActions ()
	Returns a per-label keyed map of all Actions in the registry. More...
static const RegistryEntryBase &	objData (const std::string &name)
static bool	isRegisteredObj (const std::string &name)
static const std::map< std::string, std::string > &	getDataFilePaths ()
	Returns a map of all registered data file paths (name -> path) More...
static std::string	getDataFilePath (const std::string &name)
	Gets a data path for the registered name. More...
static const std::string &	getRepositoryURL (const std::string &repo_name)
	Returns the repository URL associated with repo_name. More...
static const std::map< std::string, std::string > &	getRepos ()
	Returns a map of all registered repositories. More...
template<typename T >
static std::string	getRegisteredName ()
	returns the name() for a registered class More...

Private Member Functions
	Registry ()

Static Private Member Functions
static void	setDataFilePaths (const std::map< std::string, std::string > &data_file_paths)
	Manually set the data file paths. More...
static void	setRepos (const std::map< std::string, std::string > &repos)
	Manually set the repos. More...
static std::string	determineDataFilePath (const std::string &name, const std::string &in_tree_path)
	Internal helper for determing a root data file path (in-tree vs installed) More...
static std::string	appNameFromAppPath (const std::string &app_path)
	Internal helper for getting an application name from its path, for example: /path/to/FooBarBazApp.C -> foo_bar_baz, for use in addDeprecatedAppDataFilePath. More...

Private Attributes
std::map< std::string, std::shared_ptr< RegistryEntryBase > >	_name_to_entry
std::map< std::string, std::vector< std::shared_ptr< RegistryEntryBase > > >	_per_label_objects
std::map< std::string, std::vector< std::shared_ptr< RegistryEntryBase > > >	_per_label_actions
std::set< std::string >	_known_labels
std::map< std::string, std::string >	_data_file_paths
	Data file registry; name -> in-tree path. More...
std::map< std::string, std::string >	_repos
	Repository name -> repository URL; used for mooseDocumentedError. More...
std::map< std::string, std::string >	_type_to_classname
class	RegistryTest
	Friends for unit testing. More...
class	DataFileUtilsTest
	FRIEND_TEST (RegistryTest, determineFilePath)
	FRIEND_TEST (RegistryTest, determineFilePathFailed)
	FRIEND_TEST (RegistryTest, appNameFromAppPath)
	FRIEND_TEST (RegistryTest, appNameFromAppPathFailed)

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 161 of file Registry.h.

Constructor & Destructor Documentation

Registry() [1/3]

Registry::Registry ( Registry const &  )

delete

Don't allow creation through copy/move construction or assignment.

Registry() [2/3]

Registry::Registry ( Registry &&  )

delete

Registry() [3/3]

Registry::Registry ( )

inlineprivate

Definition at line 284 of file Registry.h.

Referenced by getRegistry().

{};

Member Function Documentation

add()

template<typename T >

static char Registry::add ( const RegistryEntryData &  base_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 173 of file Registry.h.

  {
    const auto info = std::make_shared<RegistryEntry<T>>(base_info);
    getRegistry()._per_label_objects[info->_label].push_back(info);
    getRegistry()._type_to_classname[typeid(T).name()] = info->name();
    return 0;
  }

addAction()

template<typename T >

static char Registry::addAction ( const RegistryEntryData &  base_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 185 of file Registry.h.

  {
    const auto info = std::make_shared<RegistryEntry<T>>(base_info);
    getRegistry()._per_label_actions[info->_label].push_back(info);
    getRegistry()._type_to_classname[typeid(T).name()] = info->_classname;
    return 0;
  }

addAppDataFilePath()

void Registry::addAppDataFilePath ( const std::string &  app_name, const std::string &  app_path  )

static

register search paths for an application (path determined relative to app_path); app_path should be passed as FILE from the application source file

Definition at line 128 of file Registry.C.

Referenced by addDeprecatedAppDataFilePath().

{
  // split the *App.C filename from its containing directory
  const auto dir = MooseUtils::splitFileName(app_path).first;
  // This works for both build/unity_src/ and src/base/ as the *App.C file location,
  // in case __FILE__ doesn't get overriden in unity build
  addDataFilePath(app_name, MooseUtils::pathjoin(dir, "../../data"));
}

addDataFilePath()

void Registry::addDataFilePath ( const std::string &  name, const std::string &  in_tree_path  )

static

register general search paths (folder name must be data)

Definition at line 91 of file Registry.C.

Referenced by addAppDataFilePath().

{
  if (!std::regex_search(name, std::regex("\\w+")))
    mooseError("Unallowed characters in '", name, "'");

  // Enforce that the folder is called "data", because we rely on the installed path
  // to be within PREFIX/share/<name>/data (see determineDataFilePath())
  const std::string folder = std::filesystem::path(in_tree_path).filename().c_str();
  if (folder != "data")
    mooseError("While registering data file path '",
               in_tree_path,
               "' for '",
               name,
               "': The folder must be named 'data' and it is named '",
               folder,
               "'");

  // Find either the installed or in-tree path
  const auto path = determineDataFilePath(name, in_tree_path);

  auto & dfp = getRegistry()._data_file_paths;
  const auto it = dfp.find(name);
  // Not registered yet
  if (it == dfp.end())
    dfp.emplace(name, path);
  // Registered, but with a different value
  else if (it->second != path)
    mooseError("While registering data file path '",
               path,
               "' for '",
               name,
               "': the path '",
               it->second,
               "' is already registered");
}

addDeprecatedAppDataFilePath()

void Registry::addDeprecatedAppDataFilePath ( const std::string &  app_path )

static

deprecated method; use addAppDataFilePath instead

Definition at line 138 of file Registry.C.

{
  const auto app_name = appNameFromAppPath(app_path);
  mooseDeprecated("In ",
                  app_path,
                  ":\nregisterDataFilePath() is deprecated. Use registerAppDataFilePath(\"",
                  app_name,
                  "\") instead.");
  addAppDataFilePath(app_name, app_path);
}

addKnownLabel()

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

static

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

Definition at line 84 of file Registry.C.

Referenced by MooseApp::MooseApp().

{
  getRegistry()._known_labels.insert(label);
  return 0;
}

addRepository()

void Registry::addRepository ( const std::string &  repo_name, const std::string &  repo_url  )

static

register a repository

Definition at line 160 of file Registry.C.

{
  auto & repos = getRegistry()._repos;
  const auto [it, inserted] = repos.emplace(repo_name, repo_url);
  if (!inserted && it->second != repo_url)
    mooseError("Registry::registerRepository(): The repository '",
               repo_name,
               "' is already registered with a different URL '",
               it->second,
               "'.");
}

allActions()

static const std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase> > >& Registry::allActions ( )

inlinestatic

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

Definition at line 227 of file Registry.h.

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

  {
    return getRegistry()._per_label_actions;
  }

allObjects()

static const std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase> > >& Registry::allObjects ( )

inlinestatic

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

Definition at line 222 of file Registry.h.

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

  {
    return getRegistry()._per_label_objects;
  }

appNameFromAppPath()

std::string Registry::appNameFromAppPath ( const std::string &  app_path )

staticprivate

Internal helper for getting an application name from its path, for example: /path/to/FooBarBazApp.C -> foo_bar_baz, for use in addDeprecatedAppDataFilePath.

Definition at line 209 of file Registry.C.

Referenced by addDeprecatedAppDataFilePath().

{
  // This is for deprecated use only. It assumes that the application name
  // (binary name) in the build follows our normal naming of FooBarApp -> foo_bar.
  // We need to convert the application source file to the above, for example:
  //   /path/to/FooBarBazApp.C -> foo_bar_baz
  // Ideally, we would instead have the user specify this manually so that
  // there is no ambiguity.
  std::smatch match;
  if (std::regex_search(app_path, match, std::regex("\\/([a-zA-Z0-9_]+)App\\.C$")))
  {
    std::string name = match[1];                                        // FooBarBaz
    name = std::regex_replace(name, std::regex("(?!^)([A-Z])"), "_$1"); // Foo_Bar_Baz
    name = MooseUtils::toLower(name);                                   // foo_bar_baz
    return name;
  }

  mooseError(
      "Registry::appNameFromAppPath(): Failed to parse application name from '", app_path, "'");
}

determineDataFilePath()

std::string Registry::determineDataFilePath ( const std::string &  name, const std::string &  in_tree_path  )

staticprivate

Internal helper for determing a root data file path (in-tree vs installed)

Definition at line 182 of file Registry.C.

Referenced by addDataFilePath().

{
  // TODO: Track whether or not the application is installed in a better way
  // than this, which will enable us to pick one or the other based on
  // the install state. This probably also won't work with dynamic loading, where
  // we can't necessarily get this information from the binary (as there could be
  // multiple binary paths)

  // Installed data
  const auto installed_path =
      MooseUtils::pathjoin(Moose::getExecutablePath(), "..", "share", name, "data");
  if (MooseUtils::checkFileReadable(installed_path, false, false, false))
    return MooseUtils::canonicalPath(installed_path);

  // In tree data
  if (MooseUtils::checkFileReadable(in_tree_path, false, false, false))
    return MooseUtils::canonicalPath(in_tree_path);

  mooseError("Failed to determine data file path for '",
             name,
             "'. Paths searched:\n\n  installed: ",
             installed_path,
             "\n  in-tree: ",
             in_tree_path);
}

FRIEND_TEST() [1/4]

Registry::FRIEND_TEST ( RegistryTest  , determineFilePath    )

private

FRIEND_TEST() [2/4]

Registry::FRIEND_TEST ( RegistryTest  , determineFilePathFailed    )

private

FRIEND_TEST() [3/4]

Registry::FRIEND_TEST ( RegistryTest  , appNameFromAppPath    )

private

FRIEND_TEST() [4/4]

Registry::FRIEND_TEST ( RegistryTest  , appNameFromAppPathFailed    )

private

getClassName()

template<typename T >

static std::string Registry::getClassName ( )

inlinestatic

Definition at line 194 of file Registry.h.

  {
    return libmesh_map_find(getRegistry()._type_to_classname, typeid(T).name());
  }

getDataFilePath()

std::string Registry::getDataFilePath ( const std::string &  name )

static

Gets a data path for the registered name.

Finds either the installed path or the in-tree path.

Definition at line 150 of file Registry.C.

{
  const auto & dfps = getRegistry()._data_file_paths;
  const auto it = dfps.find(name);
  if (it == dfps.end())
    mooseError("Registry::getDataFilePath(): A data file path for '", name, "' is not registered");
  return it->second;
}

getDataFilePaths()

static const std::map<std::string, std::string>& Registry::getDataFilePaths ( )

inlinestatic

Returns a map of all registered data file paths (name -> path)

Definition at line 243 of file Registry.h.

Referenced by Moose::DataFileUtils::getPath(), and ConsoleUtils::outputDataFilePaths().

  {
    return getRegistry()._data_file_paths;
  }

getRegisteredName()

template<typename T >

std::string Registry::getRegisteredName ( )

static

returns the name() for a registered class

Definition at line 326 of file Registry.h.

{
  mooseDeprecated("Use Registry::getClassName() instead.");
  return getClassName<T>();
}

getRegistry()

Registry & Registry::getRegistry ( )

static

Get the global Registry singleton.

Definition at line 23 of file Registry.C.

Referenced by add(), addAction(), addDataFilePath(), addKnownLabel(), addRepository(), allActions(), allObjects(), getClassName(), getDataFilePath(), getDataFilePaths(), Moose::DataFileUtils::getPath(), getRepos(), getRepositoryURL(), isRegisteredObj(), objData(), registerActionsTo(), registerObjectsTo(), setDataFilePaths(), and setRepos().

{
  // We need a naked new here (_not_ a smart pointer or object instance) due to what seems like a
  // bug in clang's static object destruction when using dynamic library loading.
  static Registry * registry_singleton = nullptr;
  if (!registry_singleton)
    registry_singleton = new Registry();
  return *registry_singleton;
}

getRepos()

static const std::map<std::string, std::string>& Registry::getRepos ( )

inlinestatic

Returns a map of all registered repositories.

Definition at line 259 of file Registry.h.

{ return getRegistry()._repos; }

getRepositoryURL()

const std::string & Registry::getRepositoryURL ( const std::string &  repo_name )

static

Returns the repository URL associated with repo_name.

Definition at line 173 of file Registry.C.

Referenced by moose::internal::formatMooseDocumentedError().

{
  const auto & repos = getRegistry()._repos;
  if (const auto it = repos.find(repo_name); it != repos.end())
    return it->second;
  mooseError("Registry::getRepositoryURL(): The repository '", repo_name, "' is not registered.");
}

isRegisteredObj()

static bool Registry::isRegisteredObj ( const std::string &  name )

inlinestatic

Returns

true if an object with the given name is registered

Definition at line 237 of file Registry.h.

Referenced by MooseObject::MooseObject().

  {
    return getRegistry()._name_to_entry.count(name);
  }

objData()

const RegistryEntryBase & Registry::objData ( const std::string &  name )

static

Definition at line 57 of file Registry.C.

{
  auto & r = getRegistry();

  if (const auto it = r._name_to_entry.find(name); it != r._name_to_entry.end())
    return *it->second;
  else
    mooseError("Object ", name, " is not registered yet");
}

operator=() [1/2]

Registry& Registry::operator= ( Registry const &  )

delete

operator=() [2/2]

Registry& Registry::operator= ( Registry &&  )

delete

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

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 34 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])
    {
      const auto name = obj->name();
      r._name_to_entry[name] = obj;

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

setDataFilePaths()

static void Registry::setDataFilePaths ( const std::map< std::string, std::string > &  data_file_paths )

inlinestaticprivate

Manually set the data file paths.

Used in unit testing.

Definition at line 291 of file Registry.h.

  {
    getRegistry()._data_file_paths = data_file_paths;
  }

setRepos()

static void Registry::setRepos ( const std::map< std::string, std::string > &  repos )

inlinestaticprivate

Manually set the repos.

Used in unit testing

Definition at line 300 of file Registry.h.

  {
    getRegistry()._repos = repos;
  }

Friends And Related Function Documentation

DataFileUtilsTest

friend class DataFileUtilsTest

friend

Definition at line 277 of file Registry.h.

RegistryTest

friend class RegistryTest

friend

Friends for unit testing.

Definition at line 276 of file Registry.h.

Member Data Documentation

_data_file_paths

std::map<std::string, std::string> Registry::_data_file_paths

private

Data file registry; name -> in-tree path.

Definition at line 318 of file Registry.h.

Referenced by addDataFilePath(), getDataFilePath(), getDataFilePaths(), and setDataFilePaths().

_known_labels

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

private

Definition at line 316 of file Registry.h.

Referenced by addKnownLabel().

_name_to_entry

std::map<std::string, std::shared_ptr<RegistryEntryBase> > Registry::_name_to_entry

private

Definition at line 313 of file Registry.h.

Referenced by isRegisteredObj().

_per_label_actions

std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase> > > Registry::_per_label_actions

private

Definition at line 315 of file Registry.h.

Referenced by addAction(), and allActions().

_per_label_objects

std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase> > > Registry::_per_label_objects

private

Definition at line 314 of file Registry.h.

Referenced by add(), and allObjects().

_repos

std::map<std::string, std::string> Registry::_repos

private

Repository name -> repository URL; used for mooseDocumentedError.

Definition at line 320 of file Registry.h.

Referenced by addRepository(), getRepos(), getRepositoryURL(), and setRepos().

_type_to_classname

std::map<std::string, std::string> Registry::_type_to_classname

private

Definition at line 321 of file Registry.h.

Referenced by add(), addAction(), and getClassName().

---

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

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