Factory.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 <set>
#include <vector>
#include <ctime>

// MOOSE includes
#include "Registry.h"
#include "MooseObject.h"
#include "MooseTypes.h"
#include "FileLineInfo.h"

// Forward declarations
class InputParameters;

class Factory
{
public:
  Factory(MooseApp & app);
  virtual ~Factory();

  void reg(std::shared_ptr<RegistryEntryBase> obj);

  FileLineInfo getLineInfo(const std::string & name) const;

  void associateNameToClass(const std::string & name, const std::string & class_name);

  std::string associatedClassName(const std::string & name) const;

  InputParameters getValidParams(const std::string & name) const;

  std::unique_ptr<MooseObject> createUnique(const std::string & obj_name,
                                            const std::string & name,
                                            const InputParameters & parameters,
                                            THREAD_ID tid = 0,
                                            bool print_deprecated = true);
  std::shared_ptr<MooseObject> create(const std::string & obj_name,
                                      const std::string & name,
                                      const InputParameters & parameters,
                                      THREAD_ID tid = 0,
                                      bool print_deprecated = true);

  template <typename T>
  std::unique_ptr<T> createUnique(const std::string & obj_name,
                                  const std::string & name,
                                  const InputParameters & parameters,
                                  const THREAD_ID tid = 0);
  template <typename T>
  std::shared_ptr<T> create(const std::string & obj_name,
                            const std::string & name,
                            const InputParameters & parameters,
                            const THREAD_ID tid = 0);

  template <typename T>
  std::unique_ptr<T> clone(const T & object);

  template <typename T>
  std::unique_ptr<T> copyConstruct(const T & object);

  void releaseSharedObjects(const MooseObject & moose_object, THREAD_ID tid = 0);

  void restrictRegisterableObjects(const std::vector<std::string> & names);

  const auto & registeredObjects() const { return _name_to_object; }

  bool isRegistered(const std::string & obj_name) const { return _name_to_object.count(obj_name); }

  std::vector<std::string> getConstructedObjects() const;

  MooseApp & app() { return _app; }

  const InputParameters * currentlyConstructing() const;

private:
  template <class T, class SmartPtr>
  void createCheckObjectType(const SmartPtr & object, const std::string & obj_name) const;

  template <class ptr_type>
  ptr_type createTempl(const std::string & obj_name,
                       const std::string & name,
                       const InputParameters & parameters,
                       const THREAD_ID tid,
                       const std::optional<std::string> & deprecated_method_name);

  std::time_t parseTime(std::string);

  void deprecatedMessage(const std::string obj_name) const;

  void reportUnregisteredError(const std::string & obj_name) const;

  InputParameters & initialize(const std::string & type,
                               const std::string & name,
                               const InputParameters & from_params,
                               const THREAD_ID tid);

  void finalize(const std::string & type, const MooseObject & object);

  MooseApp & _app;

  std::map<std::string, std::shared_ptr<RegistryEntryBase>> _name_to_object;

  FileLineInfoMap _name_to_line;

  std::map<std::string, std::string> _name_to_class;

  std::map<std::string, std::time_t> _deprecated_time;

  std::map<std::string, std::string> _deprecated_name;

  std::set<std::string> _registerable_objects;

  std::set<std::string> _constructed_types;

  mutable std::set<std::string> _deprecated_types;

  std::set<std::pair<std::string, std::string>> _objects_by_label;

  std::vector<const InputParameters *> _currently_constructing;

  std::map<const MooseObject *, unsigned int> _clone_counter;
};

template <class T, class SmartPtr>
void
Factory::createCheckObjectType(const SmartPtr & object, const std::string & obj_name) const
{
  if (!dynamic_cast<T *>(object.get()))
    mooseError("We expected to create an object of type '" + MooseUtils::prettyCppType<T>() +
               "'.\nInstead we received a parameters object for type '" + obj_name +
               "'.\nDid you call the wrong \"add\" method in your Action?");
}

template <typename T>
std::unique_ptr<T>
Factory::createUnique(const std::string & obj_name,
                      const std::string & name,
                      const InputParameters & parameters,
                      const THREAD_ID tid)
{
  auto object = createUnique(obj_name, name, parameters, tid, false);
  createCheckObjectType<T>(object, obj_name);
  return std::unique_ptr<T>(static_cast<T *>(object.release()));
}

template <typename T>
std::shared_ptr<T>
Factory::create(const std::string & obj_name,
                const std::string & name,
                const InputParameters & parameters,
                const THREAD_ID tid)
{
  auto object = create(obj_name, name, parameters, tid, false);
  createCheckObjectType<T>(object, obj_name);
  return std::static_pointer_cast<T>(object);
}

template <typename T>
std::unique_ptr<T>
Factory::clone(const T & object)
{
  static_assert(std::is_base_of_v<MooseObject, T>, "Not a MooseObject");

  const auto tid = object.template getParam<THREAD_ID>("_tid");
  if (tid != 0)
    mooseError("Factory::clone(): The object ",
               object.typeAndName(),
               " is threaded but cloning does not work with threaded objects");

  // Clone the parameters; we can't copy construct InputParameters
  InputParameters cloned_params = emptyInputParameters();
  cloned_params += object.parameters();
  if (const auto hit_node = object.parameters().getHitNode())
    cloned_params.setHitNode(*hit_node, {});

  // Fill the new parameters in the warehouse
  const auto type = static_cast<const MooseBase &>(object).type();
  const auto clone_count = _clone_counter[&object]++;
  const auto name = object.name() + "_clone" + std::to_string(clone_count);
  const auto & params = initialize(type, name, cloned_params, 0);

  // Construct the object
  _currently_constructing.push_back(&params);
  auto cloned_object = std::make_unique<T>(params);
  _currently_constructing.pop_back();

  // Do some sanity checking
  finalize(type, *cloned_object);

  return cloned_object;
}

template <typename T>
std::unique_ptr<T>
Factory::copyConstruct(const T & object)
{
  static_assert(std::is_base_of_v<MooseObject, T>, "Not a MooseObject");

  const auto type = static_cast<const MooseBase &>(object).type();
  if (object.hasBase())
  {
    const auto & base = object.getBase();
    if (base != "MooseMesh" && base != "RelationshipManager")
      mooseError("Copy construction of ", type, " objects is not supported.");
  }

  _currently_constructing.push_back(&object.parameters());
  auto cloned_object = std::make_unique<T>(object);
  _currently_constructing.pop_back();

  finalize(type, *cloned_object);

  return cloned_object;
}