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, const bool app=true, const std::optional< std::string > &info={})
	register general search paths; "app" is whether or not the path is an app path 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	addMissingDataFilePath (const std::string &name, const std::string &info)
	register a data file path as missing, along with info about how it can be added 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...
static void	checkDataFilePathName (const std::string &name)
	Check a data file path for valid characters. More...
static void	addDataFilePathCapability (const std::string &name, const std::optional< std::string > &path={}, const std::optional< std::string > &extra_info={})
	Add a data file path capability. 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)
	FRIEND_TEST (RegistryTest, addDataFilePathCapability)

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 171 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 302 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 183 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 195 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 144 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, const bool  app = true, const std::optional< std::string > &  info = {}  )

static

register general search paths; "app" is whether or not the path is an app path

Definition at line 92 of file Registry.C.

Referenced by addAppDataFilePath().

{
  checkDataFilePathName(name);

  // Enforce that the folder is called "data", because we rely on the installed path
  // to be within PREFIX/share/<name>/data (see determineDataFilePath())
  if (is_app)
  {
    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);
    addDataFilePathCapability(name, path, info);
  }
  // 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");
}

addDataFilePathCapability()

void Registry::addDataFilePathCapability ( const std::string &  name, const std::optional< std::string > &  path = {}, const std::optional< std::string > &  extra_info = {}  )

staticprivate

Add a data file path capability.

Definition at line 256 of file Registry.C.

Referenced by addDataFilePath(), and addMissingDataFilePath().

{
  std::string doc = "Named data path '" + name + "' is ";
  if (path)
    doc += "available at '" + *path + "'";
  else
    doc += "not available";
  if (extra_info)
    doc += "; " + *extra_info;
  doc += ".";

  auto & capabilities = Moose::internal::Capabilities::getCapabilities({});
  capabilities.add("data_" + name, bool(path), doc);
}

addDeprecatedAppDataFilePath()

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

static

deprecated method; use addAppDataFilePath instead

Definition at line 154 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 85 of file Registry.C.

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

addMissingDataFilePath()

void Registry::addMissingDataFilePath ( const std::string &  name, const std::string &  info  )

static

register a data file path as missing, along with info about how it can be added

Definition at line 137 of file Registry.C.

{
  checkDataFilePathName(name);
  addDataFilePathCapability(name, {}, info);
}

addRepository()

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

static

register a repository

Definition at line 176 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 242 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 237 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 225 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, "'");
}

checkDataFilePathName()

void Registry::checkDataFilePathName ( const std::string &  name )

staticprivate

Check a data file path for valid characters.

Definition at line 247 of file Registry.C.

Referenced by addDataFilePath(), and addMissingDataFilePath().

{
  if (!std::regex_search(name, std::regex("[a-z0-9_]+")))
    mooseError("Unallowed characters in data file path name '",
               name,
               "'; allowed characters = a-z, 0-9, _");
}

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 198 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/5]

Registry::FRIEND_TEST ( RegistryTest  , determineFilePath    )

private

FRIEND_TEST() [2/5]

Registry::FRIEND_TEST ( RegistryTest  , determineFilePathFailed    )

private

FRIEND_TEST() [3/5]

Registry::FRIEND_TEST ( RegistryTest  , appNameFromAppPath    )

private

FRIEND_TEST() [4/5]

Registry::FRIEND_TEST ( RegistryTest  , appNameFromAppPathFailed    )

private

FRIEND_TEST() [5/5]

Registry::FRIEND_TEST ( RegistryTest  , addDataFilePathCapability    )

private

getClassName()

template<typename T >

static std::string Registry::getClassName ( )

inlinestatic

Definition at line 204 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 166 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 258 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 352 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 24 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 274 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 189 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 252 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 58 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 69 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 35 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 309 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 318 of file Registry.h.

  {
    getRegistry()._repos = repos;
  }

Friends And Related Function Documentation

DataFileUtilsTest

friend class DataFileUtilsTest

friend

Definition at line 293 of file Registry.h.

RegistryTest

friend class RegistryTest

friend

Friends for unit testing.

Definition at line 292 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 344 of file Registry.h.

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

_known_labels

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

private

Definition at line 342 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 339 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 341 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 340 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 346 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 347 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