Registry.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "InputParameters.h"

#include <string>
#include <vector>
#include <set>
#include <map>
#include <memory>
#include <optional>

#include "libmesh/utility.h"

#ifdef MOOSE_UNIT_TEST
#include <gtest/gtest.h>
#endif

#define combineNames1(X, Y) X##Y
#define combineNames(X, Y) combineNames1(X, Y)

#define registerKnownLabel(X)                                                                      \
  static char combineNames(dummy_var_for_known_label, __COUNTER__) = Registry::addKnownLabel(X)

#define registerMooseAction(app, classname, task)                                                  \
  static char combineNames(dummyvar_for_registering_action_##classname, __COUNTER__) =             \
      Registry::addAction<classname>({app, #classname, "", task, __FILE__, __LINE__, "", ""})

#define registerMooseObject(app, classname)                                                        \
  static char combineNames(dummyvar_for_registering_obj_##classname, __COUNTER__) =                \
      Registry::add<classname>({app, #classname, "", "", __FILE__, __LINE__, "", ""})

#define registerADMooseObject(app, classname) registerMooseObject(app, classname)

#define registerMooseObjectAliased(app, classname, alias)                                          \
  static char combineNames(dummyvar_for_registering_obj_##classname, __COUNTER__) =                \
      Registry::add<classname>({app, #classname, alias, "", __FILE__, __LINE__, "", ""})

#define registerMooseObjectDeprecated(app, classname, time)                                        \
  static char combineNames(dummyvar_for_registering_obj_##classname, __COUNTER__) =                \
      Registry::add<classname>({app, #classname, "", "", __FILE__, __LINE__, time, ""})

#define registerADMooseObjectDeprecated(app, classname, time)                                      \
  registerMooseObjectDeprecated(app, classname, time)

#define registerMooseObjectReplaced(app, classname, time, replacement)                             \
  static char combineNames(dummyvar_for_registering_obj_##classname, __COUNTER__) =                \
      Registry::add<classname>({app, #classname, "", "", __FILE__, __LINE__, time, #replacement})

#define registerMooseObjectRenamed(app, orig_class, time, new_class)                               \
  static char combineNames(dummyvar_for_registering_obj_##orig_class, __COUNTER__) =               \
      Registry::add<new_class>(                                                                    \
          {app, #new_class, #orig_class, #orig_class, __FILE__, __LINE__, time, #new_class})

#define registerADMooseObjectRenamed(app, orig_class, time, new_class)                             \
  registerMooseObjectRenamed(app, orig_class, time, new_class)

#define registerNonAppDataFilePath(name, path) Registry::addDataFilePath(name, path, false)
#define registerNonAppDataFilePathWithInfo(name, path, info)                                       \
  Registry::addDataFilePath(name, path, false, info)
#define registerAppDataFilePath(app) Registry::addAppDataFilePath(app, __FILE__)
#define registerMissingDataFilePath(name, info) Registry::addMissingDataFilePath(name, info)
#define registerDataFilePath() Registry::addDeprecatedAppDataFilePath(__FILE__)

#define registerRepository(repo_name, repo_url) Registry::addRepository(repo_name, repo_url);

class Factory;
class ActionFactory;
class MooseObject;
class Action;
struct RegistryEntryBase;

struct RegistryEntryData
{
  std::string _label;
  std::string _classname;
  std::string _alias;
  std::string _name;
  std::string _file;
  int _line;
  std::string _deprecated_time;
  std::string _replaced_by;
};

struct RegistryEntryBase : public RegistryEntryData
{
  RegistryEntryBase(const RegistryEntryData & data) : RegistryEntryData(data) {}
  virtual ~RegistryEntryBase() {}
  virtual std::unique_ptr<MooseObject> build(const InputParameters & parameters) = 0;
  virtual std::shared_ptr<MooseObject> buildShared(const InputParameters & parameters) = 0;
  virtual std::shared_ptr<Action> buildAction(const InputParameters & parameters) = 0;
  virtual InputParameters buildParameters() = 0;
  std::string name() const
  {
    std::string name = _name;
    if (name.empty())
      name = _alias;
    if (name.empty())
      name = _classname;
    return name;
  }
};

template <typename T>
struct RegistryEntry : public RegistryEntryBase
{
  RegistryEntry(const RegistryEntryData & data);
  virtual std::unique_ptr<MooseObject> build(const InputParameters & parameters) override;
  virtual std::shared_ptr<MooseObject> buildShared(const InputParameters & parameters) override;
  virtual std::shared_ptr<Action> buildAction(const InputParameters & parameters) override;
  virtual InputParameters buildParameters() override;
};

class Registry
{
public:
  static Registry & getRegistry();

  template <typename T>
  static char add(const RegistryEntryData & base_info)
  {
    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;
  }

  template <typename T>
  static char addAction(const RegistryEntryData & base_info)
  {
    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;
  }

  template <typename T>
  static std::string getClassName()
  {
    return libmesh_map_find(getRegistry()._type_to_classname, typeid(T).name());
  }

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

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

  static char addKnownLabel(const std::string & label);

  static void addDataFilePath(const std::string & name,
                              const std::string & in_tree_path,
                              const bool app = true,
                              const std::optional<std::string> & info = {});
  static void addAppDataFilePath(const std::string & app_name, const std::string & app_path);
  static void addMissingDataFilePath(const std::string & name, const std::string & info);
  static void addDeprecatedAppDataFilePath(const std::string & app_path);

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

  static const std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase>>> & allObjects()
  {
    return getRegistry()._per_label_objects;
  }
  static const std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase>>> & allActions()
  {
    return getRegistry()._per_label_actions;
  }

  static const RegistryEntryBase & objData(const std::string & name);

  static bool isRegisteredObj(const std::string & name)
  {
    return getRegistry()._name_to_entry.count(name);
  }

  static const std::map<std::string, std::string> & getDataFilePaths()
  {
    return getRegistry()._data_file_paths;
  }
  static std::string getDataFilePath(const std::string & name);

  static const std::string & getRepositoryURL(const std::string & repo_name);
  static const std::map<std::string, std::string> & getRepos() { return getRegistry()._repos; }

  template <typename T>
  static std::string getRegisteredName();

  Registry(Registry const &) = delete;
  Registry & operator=(Registry const &) = delete;

  Registry(Registry &&) = delete;
  Registry & operator=(Registry &&) = delete;

private:
#ifdef MOOSE_UNIT_TEST
  friend class RegistryTest;
  friend class DataFileUtilsTest;
  FRIEND_TEST(RegistryTest, determineFilePath);
  FRIEND_TEST(RegistryTest, determineFilePathFailed);
  FRIEND_TEST(RegistryTest, appNameFromAppPath);
  FRIEND_TEST(RegistryTest, appNameFromAppPathFailed);
  FRIEND_TEST(RegistryTest, addDataFilePathCapability);
#endif

  Registry() {};

  static void setDataFilePaths(const std::map<std::string, std::string> & data_file_paths)
  {
    getRegistry()._data_file_paths = data_file_paths;
  }
  static void setRepos(const std::map<std::string, std::string> & repos)
  {
    getRegistry()._repos = repos;
  }

  static std::string determineDataFilePath(const std::string & name,
                                           const std::string & in_tree_path);

  static std::string appNameFromAppPath(const std::string & app_path);

  static void checkDataFilePathName(const std::string & name);

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

  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;
  std::map<std::string, std::string> _repos;
  std::map<std::string, std::string> _type_to_classname;
};

template <typename T>
std::string
Registry::getRegisteredName()
{
  mooseDeprecated("Use Registry::getClassName() instead.");
  return getClassName<T>();
}

template <typename T>
RegistryEntry<T>::RegistryEntry(const RegistryEntryData & data) : RegistryEntryBase(data)
{
  static_assert(std::is_base_of_v<MooseObject, T> || std::is_base_of_v<Action, T>,
                "Not derived from MooseObject or Action");
}

template <typename T>
std::unique_ptr<MooseObject>
RegistryEntry<T>::build(const InputParameters & parameters)
{
  if constexpr (std::is_base_of_v<MooseObject, T>)
    return std::make_unique<T>(parameters);
  mooseError(MooseUtils::prettyCppType<T>(), " to be built is not a MooseObject.");
}
template <typename T>
std::shared_ptr<MooseObject>
RegistryEntry<T>::buildShared(const InputParameters & parameters)
{
  if constexpr (std::is_base_of_v<MooseObject, T>)
    return std::make_shared<T>(parameters);
  mooseError(MooseUtils::prettyCppType<T>(), " to be built is not a MooseObject.");
}

template <typename T>
std::shared_ptr<Action>
RegistryEntry<T>::buildAction(const InputParameters & parameters)
{
  if constexpr (!std::is_base_of_v<Action, T>)
    mooseError("The action to be built is not derived from Action.");
  else
    return std::make_shared<T>(parameters);
}

template <typename T>
InputParameters
RegistryEntry<T>::buildParameters()
{
  auto params = T::validParams();
  return params;
}