Factory Class Reference

Generic factory class for build all sorts of objects. More...

#include <Factory.h>

Public Member Functions
	Factory (MooseApp &app)
virtual	~Factory ()
void	reg (std::shared_ptr< RegistryEntryBase > obj)
FileLineInfo	getLineInfo (const std::string &name) const
	Gets file and line information where an object was initially registered.
void	associateNameToClass (const std::string &name, const std::string &class_name)
	Associates an object name with a class name.
std::string	associatedClassName (const std::string &name) const
	Get the associated class name for an object name.
InputParameters	getValidParams (const std::string &name) const
	Get valid parameters for the object.
template<typename T >
std::unique_ptr< T >	clone (const T &object)
	Clones the object object.
template<typename T >
std::unique_ptr< T >	copyConstruct (const T &object)
	Copy constructs the object object.
void	releaseSharedObjects (const MooseObject &moose_object, THREAD_ID tid=0)
	Releases any shared resources created as a side effect of creating an object through the Factory::create method(s).
void	restrictRegisterableObjects (const std::vector< std::string > &names)
	Calling this object with a non-empty vector will cause this factory to ignore registrations from any object not contained within the list.
const auto &	registeredObjects () const
	Returns a reference to the map from names to RegistryEntryBase pointers.
bool	isRegistered (const std::string &obj_name) const
	Returns a Boolean indicating whether an object type has been registered.
std::vector< std::string >	getConstructedObjects () const
	Get a list of all constructed Moose Object types.
MooseApp &	app ()
const InputParameters *	currentlyConstructing () 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)
	Build an object (must be registered) - THIS METHOD IS DEPRECATED (Use create<T>())
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)
	Build an object (must be registered)
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)

Private Member Functions
template<class T , class SmartPtr >
void	createCheckObjectType (const SmartPtr &object, const std::string &obj_name) const
	Internal method for checking if the created smart pointer is of the correct expected type.
MooseApp &	_app
	Reference to the application.
std::map< std::string, std::shared_ptr< RegistryEntryBase > >	_name_to_object
	Storage for pointers to the object registry entry.
FileLineInfoMap	_name_to_line
std::map< std::string, std::string >	_name_to_class
	Object name to class name association.
std::map< std::string, std::time_t >	_deprecated_time
	Storage for deprecated object expiration dates.
std::map< std::string, std::string >	_deprecated_name
	Storage for the deprecated objects that have replacements.
std::set< std::string >	_registerable_objects
	The list of objects that may be registered.
std::set< std::string >	_constructed_types
	Constructed Moose Object types.
std::set< std::string >	_deprecated_types
	Set of deprecated object types that have been printed.
std::set< std::pair< std::string, std::string > >	_objects_by_label
	set<label/appname, objectname> used to track if an object previously added is being added again - which is okay/allowed, while still allowing us to detect/reject cases of duplicate object name registration where the label/appname is not identical.
std::vector< const InputParameters * >	_currently_constructing
	The object's parameters that are currently being constructed (if any).
std::map< const MooseObject *, unsigned int >	_clone_counter
	Counter for keeping track of the number of times an object with a given name has been cloned so that we can continue to create objects with unique names.
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)
	Internal method for creating a MooseObject, either as a shared_ptr or as a unique_ptr.
std::time_t	parseTime (std::string)
	Parse time string (mm/dd/yyyy HH:MM)
void	deprecatedMessage (const std::string obj_name) const
	Show the appropriate message for deprecated objects.
void	reportUnregisteredError (const std::string &obj_name) const
	Prints error information when an object is not registered.
InputParameters &	initialize (const std::string &type, const std::string &name, const InputParameters &from_params, const THREAD_ID tid)
	Initializes the data structures and the parameters (in the InputParameterWarehouse) for the object with the given state.
void	finalize (const std::string &type, const MooseObject &object)
	Finalizes the creaction of object of type type.

Detailed Description

Generic factory class for build all sorts of objects.

Definition at line 28 of file Factory.h.

Constructor & Destructor Documentation

Factory()

Factory::Factory

(

MooseApp &

app

)

Definition at line 18 of file Factory.C.

: _app(app) {}

~Factory()

Factory::~Factory ( )

virtual

Definition at line 20 of file Factory.C.

{}

Member Function Documentation

app()

MooseApp & Factory::app ( )

inline

Definition at line 159 of file Factory.h.

{ return _app; }

associatedClassName()

std::string Factory::associatedClassName

(

const std::string &

name

)

const

Get the associated class name for an object name.

This will return an empty string if the name was not previously associated with a class name via associateNameToClass()

Definition at line 296 of file Factory.C.

{
  auto it = _name_to_class.find(name);
  if (it == _name_to_class.end())
    return "";
  else
    return it->second;
}

Referenced by Moose::Builder::buildJsonSyntaxTree().

associateNameToClass()

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

Associates an object name with a class name.

Primarily used with the registerNamed* macros to store the mapping between the object name and the class that implements the object.

Definition at line 290 of file Factory.C.

{
  _name_to_class[name] = class_name;
}

Referenced by Registry::registerObjectsTo().

clone()

template<typename T >

std::unique_ptr< T > Factory::clone

(

const T &

object

)

Clones the object object.

Under the hood, this creates a copy of the InputParameters from object and constructs a new object with the copied parameters. The suffix _clone will be added to the object's name, where is incremented each time the object is cloned.

Definition at line 323 of file Factory.h.

{
  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;
}

Referenced by LibmeshPartitioner::clone(), BlockWeightedPartitioner::clone(), CopyMeshPartitioner::clone(), GridPartitioner::clone(), HierarchicalGridPartitioner::clone(), RandomPartitioner::clone(), and SingleRankPartitioner::clone().

copyConstruct()

template<typename T >

std::unique_ptr< T > Factory::copyConstruct

(

const T &

object

)

Copy constructs the object object.

Under the hood, the new object's parameters will point to the same address as the parameters in object. This can be dangerous and thus this is only allowed for a subset of objects.

Definition at line 358 of file Factory.h.

{
  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;
}

Referenced by RedistributeProperties::clone(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), FileMesh::safeClone(), GeneratedMesh::safeClone(), ImageMesh::safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), and MFEMMesh::safeClone().

create() [1/2]

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 = 0
	)

Definition at line 311 of file Factory.h.

{
  auto object = create(obj_name, name, parameters, tid, false);
  createCheckObjectType<T>(object, obj_name);
  return std::static_pointer_cast<T>(object);
}

create() [2/2]

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

Definition at line 142 of file Factory.C.

{
  std::optional<std::string> deprecated_method_name;
  if (print_deprecated)
    deprecated_method_name = "create";
  return createTempl<std::shared_ptr<MooseObject>>(
      obj_name, name, parameters, tid, deprecated_method_name);
}

Referenced by AddControlAction::act(), AddPeriodicBCAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), MaterialDerivativeTestAction::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), SetupMeshAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), MooseEigenSystem::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addObject(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), and create().

createCheckObjectType()

template<class T , class SmartPtr >

void Factory::createCheckObjectType ( const SmartPtr &  object, const std::string &  obj_name  ) const

private

Internal method for checking if the created smart pointer is of the correct expected type.

Used in create<T> and createUnique<T>.

Definition at line 289 of file Factory.h.

{
  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?");
}

createTempl()

template<class ptr_type >

ptr_type Factory::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  )

private

Internal method for creating a MooseObject, either as a shared_ptr or as a unique_ptr.

This is needed because we need to explicitly create objects that are requested as a shared_ptr with make_shared, so that the std::enable_shared_from_this interface will work for those objects.

We avoid code duplication by putting the creation logic for shared_ptr and unique_ptr in the same method.

This is explicitly instantiated for std::unique_ptr<MooseObject> and std::shared_ptr<MooseObject> in Factory.C.

Parameters

obj_name	Type of the object being constructed
name	Name for the object
parameters	Parameters this object should have
tid	The thread id that this copy will be created for
deprecated_method_name	The name of the method to throw a deprecated warning for, if any

Returns

The created MooseObject

Definition at line 88 of file Factory.C.

{
  static_assert(std::is_same_v<ptr_type, std::unique_ptr<MooseObject>> ||
                    std::is_same_v<ptr_type, std::shared_ptr<MooseObject>>,
                "Invalid ptr_type");
 
  if (deprecated_method_name)
  {
    const std::string name = "Factory::" + *deprecated_method_name;
    mooseDeprecated(name + "() is deprecated, please use name" + "<T>() instead");
  }
 
  // Build the parameters that are stored in the InputParameterWarehouse for this
  // object, set a few other things and do a little error checking
  auto & warehouse_params = initialize(obj_name, name, parameters, tid);
 
  // Mark that we're constructing this object
  _currently_constructing.push_back(&warehouse_params);
 
  // Construct the object
  auto & registry_entry = *_name_to_object.at(obj_name);
  ptr_type obj;
  if constexpr (std::is_same_v<ptr_type, std::unique_ptr<MooseObject>>)
    obj = registry_entry.build(warehouse_params);
  else
    obj = registry_entry.buildShared(warehouse_params);
 
  // Done constructing the object
  _currently_constructing.pop_back();
 
  finalize(obj_name, *obj);
 
  return obj;
}

createUnique() [1/2]

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 = 0
	)

Build an object (must be registered)

Parameters

obj_name	Type of the object being constructed
name	Name for the object
parameters	Parameters this object should have
tid	The thread id that this copy will be created for

Returns

The created object

Definition at line 299 of file Factory.h.

{
  auto object = createUnique(obj_name, name, parameters, tid, false);
  createCheckObjectType<T>(object, obj_name);
  return std::unique_ptr<T>(static_cast<T *>(object.release()));
}

createUnique() [2/2]

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

Build an object (must be registered) - THIS METHOD IS DEPRECATED (Use create<T>())

Parameters

obj_name	Type of the object being constructed
name	Name for the object
parameters	Parameters this object should have
tid	The thread id that this copy will be created for
print_deprecated	controls the deprecated message

Returns

The created object

Definition at line 128 of file Factory.C.

{
  std::optional<std::string> deprecated_method_name;
  if (print_deprecated)
    deprecated_method_name = "createUnique";
  return createTempl<std::unique_ptr<MooseObject>>(
      obj_name, name, parameters, tid, deprecated_method_name);
}

Referenced by ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), and createUnique().

currentlyConstructing()

const InputParameters * Factory::currentlyConstructing

(

)

const

Returns

The InputParameters for the object that is currently being constructed, if any.

Can be used to ensure that all MooseObjects are created using the Factory

Definition at line 278 of file Factory.C.

{
  return _currently_constructing.size() ? _currently_constructing.back() : nullptr;
}

Referenced by MooseObject::MooseObject().

deprecatedMessage()

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

private

Show the appropriate message for deprecated objects.

Parameters

obj_name

Name of the deprecated object

Definition at line 190 of file Factory.C.

{
  const auto time_it = _deprecated_time.find(obj_name);
 
  // If the object is not deprecated return
  if (time_it == _deprecated_time.end())
    return;
 
  // If the message has already been printed, return
  if (_deprecated_types.count(obj_name))
    return;
  _deprecated_types.emplace(obj_name);
 
  // Get the current time
  std::time_t now;
  time(&now);
 
  // Get the stop time
  std::time_t t_end = time_it->second;
 
  // Message storage
  std::ostringstream msg;
 
  const auto name_it = _deprecated_name.find(obj_name);
 
  // Expired object
  if (now > t_end)
  {
    msg << "***** Invalid Object: " << obj_name << " *****\n";
    msg << "Expired on " << ctime(&t_end);
 
    // Append replacement object, if it exists
    if (name_it != _deprecated_name.end())
      msg << "Update your application using the '" << name_it->second << "' object";
 
    // Produce the error message
    mooseDeprecationExpiredNoTrace(msg.str());
  }
 
  // Expiring object
  else
  {
    // Build the basic message
    msg << "Deprecated Object: " << obj_name << "\n";
    msg << "This object will be removed on " << ctime(&t_end);
 
    // Append replacement object, if it exists
    if (name_it != _deprecated_name.end())
      msg << "Replace " << obj_name << " with " << name_it->second;
 
    // Produce the error message
    mooseDeprecatedNoTrace(msg.str());
  }
}

Referenced by getValidParams(), and initialize().

finalize()

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

private

Finalizes the creaction of object of type type.

This will do some sanity checking on whether or not the parameters in the created object match the valid paramters of the associated type.

Definition at line 350 of file Factory.C.

{
  // Make sure no unexpected parameters were added by the object's constructor or by the action
  // initiating this create call.  All parameters modified by the constructor must have already
  // been specified in the object's validParams function.
  InputParameters orig_params = getValidParams(type);
  const auto & object_params = object.parameters();
  if (orig_params.n_parameters() != object_params.n_parameters())
  {
    std::set<std::string> orig, populated;
    for (const auto & it : orig_params)
      orig.emplace(it.first);
    for (const auto & it : object_params)
      populated.emplace(it.first);
 
    std::set<std::string> diff;
    std::set_difference(populated.begin(),
                        populated.end(),
                        orig.begin(),
                        orig.end(),
                        std::inserter(diff, diff.begin()));
 
    if (!diff.empty())
    {
      std::stringstream ss;
      for (const auto & name : diff)
        ss << ", " << name;
      object.mooseError("Attempted to set unregistered parameter(s):\n    ", ss.str().substr(2));
    }
  }
}

Referenced by clone(), copyConstruct(), and createTempl().

getConstructedObjects()

std::vector< std::string > Factory::getConstructedObjects

(

)

const

Get a list of all constructed Moose Object types.

Definition at line 269 of file Factory.C.

{
  std::vector<std::string> list;
  for (const auto & name : _constructed_types)
    list.push_back(name);
  return list;
}

getLineInfo()

FileLineInfo Factory::getLineInfo

(

const std::string &

name

)

const

Gets file and line information where an object was initially registered.

Parameters

name	Object name

Returns

The FileLineInfo associated with name

Definition at line 284 of file Factory.C.

{
  return _name_to_line.getInfo(name);
}

Referenced by Moose::Builder::buildJsonSyntaxTree(), and MooseServer::gatherDocumentDefinitionLocations().

getValidParams()

InputParameters Factory::getValidParams

(

const std::string &

name

)

const

Get valid parameters for the object.

Parameters

name	Name of the object whose parameter we are requesting

Returns

Parameters of the object

Definition at line 68 of file Factory.C.

{
  const auto it = _name_to_object.find(obj_name);
 
  // Check if the object is registered
  if (it == _name_to_object.end())
    reportUnregisteredError(obj_name);
 
  // Print out deprecated message, if it exists
  deprecatedMessage(obj_name);
 
  // Return the parameters
  auto params = it->second->buildParameters();
  params.addPrivateParam(MooseBase::app_param, &_app);
 
  return params;
}

Referenced by ElementIDOutputAction::act(), AddPeriodicBCAction::act(), AutoCheckpointAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateDisplacedProblemAction::act(), CreateProblemDefaultAction::act(), DisplayGhostingAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), SetAdaptivityOptionsAction::act(), SetupMeshAction::act(), SetupResidualDebugAction::act(), SetupTimeStepperAction::act(), DiffusionCG::addBoundaryConditionsFromComponents(), DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), DiffusionPhysicsBase::addInitialConditionsFromComponents(), FEProblem::addLineSearch(), ComponentMaterialPropertyInterface::addMaterials(), BatchMeshGeneratorAction::addMeshGenerators(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), DiffusionCG::addSolverVariables(), DiffusionFV::addSolverVariables(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), finalize(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), DiffusionFV::getAdditionalRMParams(), MooseServer::getHoverDisplayText(), FEProblemBase::getKokkosFunction(), MooseServer::getObjectParameters(), MaterialOutputAction::getParams(), OverlayMeshGenerator::OverlayMeshGenerator(), ProjectedStatefulMaterialStorageAction::processProperty(), TransientBase::setupTimeIntegrator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

initialize()

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

private

Initializes the data structures and the parameters (in the InputParameterWarehouse) for the object with the given state.

Definition at line 306 of file Factory.C.

{
  // Pointer to the object constructor
  const auto it = _name_to_object.find(type);
 
  // Check if the object is registered
  if (it == _name_to_object.end())
    reportUnregisteredError(type);
 
  // Print out deprecated message, if it exists
  deprecatedMessage(type);
 
  // Create the actual parameters object that the object will reference
  InputParameters & params =
      _app.getInputParameterWarehouse().addInputParameters(name, from_params, tid, {});
 
  // Add the hit node from the action if it isn't set already (it might be set
  // already because someone had a better option than just the action)
  // If it isn't set, it typically means that this object was created by a
  // non-MooseObjectAction Action
  if (!params.getHitNode() || params.getHitNode()->isRoot())
    if (const auto hit_node = _app.getCurrentActionHitNode())
      params.setHitNode(*hit_node, {});
 
  // Set the type parameter
  params.set<std::string>(MooseBase::type_param) = type;
 
  // Check to make sure that all required parameters are supplied
  params.finalize(name);
 
  // register type name as constructed
  _constructed_types.insert(type);
 
  // add FEProblem pointers to object's params object
  if (_app.actionWarehouse().problemBase())
    _app.actionWarehouse().problemBase()->setInputParametersFEProblem(params);
 
  return params;
}

Referenced by clone(), and createTempl().

isRegistered()

bool Factory::isRegistered ( const std::string &  obj_name ) const

inline

Returns a Boolean indicating whether an object type has been registered.

Definition at line 152 of file Factory.h.

{ return _name_to_object.count(obj_name); }

Referenced by MooseServer::gatherDocumentDefinitionLocations(), MooseServer::getHoverDisplayText(), and MooseServer::getObjectParameters().

parseTime()

std::time_t Factory::parseTime ( std::string  t_str )

private

Parse time string (mm/dd/yyyy HH:MM)

Parameters

t_str

String with the object expiration date, this must be in the form mm/dd/yyyy HH:MM

Returns

A time_t object with the expiration date

Definition at line 168 of file Factory.C.

{
  // The string must be a certain length to be valid
  if (t_str.size() != 16)
    mooseError("The deprecated time not formatted correctly; it must be given as mm/dd/yyyy HH:MM");
 
  // Store the time, the time must be specified as: mm/dd/yyyy HH:MM
  std::time_t t_end;
  struct tm * t_end_info;
  time(&t_end);
  t_end_info = localtime(&t_end);
  t_end_info->tm_mon = std::atoi(t_str.substr(0, 2).c_str()) - 1;
  t_end_info->tm_mday = std::atoi(t_str.substr(3, 2).c_str());
  t_end_info->tm_year = std::atoi(t_str.substr(6, 4).c_str()) - 1900;
  t_end_info->tm_hour = std::atoi(t_str.substr(11, 2).c_str()) + 1;
  t_end_info->tm_min = std::atoi(t_str.substr(14, 2).c_str());
  t_end_info->tm_sec = 0;
  t_end = mktime(t_end_info);
  return t_end;
}

Referenced by reg().

reg()

void Factory::reg

(

std::shared_ptr< RegistryEntryBase >

obj

)

Definition at line 23 of file Factory.C.

{
  const std::string obj_name = obj->name();
  const std::string & label = obj->_label;
  const std::string & deprecated_time = obj->_deprecated_time;
  const std::string & replacement_name = obj->_replaced_by;
  const std::string & file = obj->_file;
  const int line = obj->_line;
 
  // do nothing if we have already added this exact object before
  auto key = std::make_pair(label, obj_name);
  if (_objects_by_label.find(key) != _objects_by_label.end())
    return;
 
  /*
   * If _registerable_objects has been set the user has requested that we only register some
   * subset
   * of the objects for a dynamically loaded application. The objects listed in *this*
   * application's
   * registerObjects() method will have already been registered before that member was set.
   *
   * If _registerable_objects is empty, the factory is unrestricted
   */
  if (_registerable_objects.empty() ||
      _registerable_objects.find(obj_name) != _registerable_objects.end())
  {
    if (_name_to_object.find(obj_name) != _name_to_object.end())
      mooseError("Object '" + obj_name + "' registered from multiple files: ",
                 file,
                 " and ",
                 _name_to_line.getInfo(obj_name).file());
    _name_to_object[obj_name] = obj;
    _objects_by_label.insert(key);
  }
  _name_to_line.addInfo(obj_name, file, line);
 
  if (!replacement_name.empty())
    _deprecated_name[obj_name] = replacement_name;
  if (!deprecated_time.empty())
    _deprecated_time[obj_name] = parseTime(deprecated_time);
 
  // TODO: Possibly store and print information about objects that are skipped here?
}

Referenced by Registry::registerObjectsTo().

registeredObjects()

const auto & Factory::registeredObjects ( ) const

inline

Returns a reference to the map from names to RegistryEntryBase pointers.

Definition at line 147 of file Factory.h.

{ return _name_to_object; }

Referenced by MooseServer::addValuesToList(), Moose::Builder::buildFullTree(), and Moose::Builder::buildJsonSyntaxTree().

releaseSharedObjects()

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

Releases any shared resources created as a side effect of creating an object through the Factory::create method(s).

Currently, this object just moves the InputParameters object from the InputParameterWarehouse. Normally this method does not need to be explicitly called during a normal simulation.

Definition at line 156 of file Factory.C.

{
  _app.getInputParameterWarehouse().removeInputParameters(moose_object, tid, {});
}

Referenced by AddPeriodicBCAction::act(), SetAdaptivityOptionsAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), and AddActionComponentAction::addRelationshipManagers().

reportUnregisteredError()

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

private

Prints error information when an object is not registered.

Definition at line 246 of file Factory.C.

{
  std::ostringstream oss;
  std::set<std::string> paths = _app.getLoadedLibraryPaths();
 
  oss << "A '" + obj_name + "' is not a registered object.\n";
 
  if (!paths.empty())
  {
    oss << "\nWe loaded objects from the following libraries and still couldn't find your "
           "object:\n\t";
    std::copy(paths.begin(), paths.end(), infix_ostream_iterator<std::string>(oss, "\n\t"));
    oss << '\n';
  }
 
  oss << "\nIf you are trying to find this object in a dynamically loaded library, make sure that\n"
         "the library can be found either in your \"Problem/library_path\" parameter or in the\n"
         "MOOSE_LIBRARY_PATH environment variable.";
 
  mooseError(oss.str());
}

Referenced by getValidParams(), and initialize().

restrictRegisterableObjects()

void Factory::restrictRegisterableObjects

(

const std::vector< std::string > &

names

)

Calling this object with a non-empty vector will cause this factory to ignore registrations from any object not contained within the list.

Parameters

names

a vector containing the names of objects that this factory will register

Definition at line 162 of file Factory.C.

{
  _registerable_objects.insert(names.begin(), names.end());
}

Referenced by DynamicObjectRegistrationAction::DynamicObjectRegistrationAction().

Member Data Documentation

_app

MooseApp& Factory::_app

private

Reference to the application.

Definition at line 247 of file Factory.h.

Referenced by app(), getValidParams(), initialize(), releaseSharedObjects(), and reportUnregisteredError().

_clone_counter

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

private

Counter for keeping track of the number of times an object with a given name has been cloned so that we can continue to create objects with unique names.

Definition at line 284 of file Factory.h.

Referenced by clone().

_constructed_types

std::set<std::string> Factory::_constructed_types

private

Constructed Moose Object types.

Definition at line 267 of file Factory.h.

Referenced by getConstructedObjects(), and initialize().

_currently_constructing

std::vector<const InputParameters *> Factory::_currently_constructing

private

The object's parameters that are currently being constructed (if any).

This is a vector because we create within create, thus the last entry is the one that is being constructed at the moment

Definition at line 280 of file Factory.h.

Referenced by clone(), copyConstruct(), createTempl(), and currentlyConstructing().

_deprecated_name

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

private

Storage for the deprecated objects that have replacements.

Definition at line 261 of file Factory.h.

Referenced by deprecatedMessage(), and reg().

_deprecated_time

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

private

Storage for deprecated object expiration dates.

Definition at line 258 of file Factory.h.

Referenced by deprecatedMessage(), and reg().

_deprecated_types

std::set<std::string> Factory::_deprecated_types

mutableprivate

Set of deprecated object types that have been printed.

Definition at line 270 of file Factory.h.

Referenced by deprecatedMessage().

_name_to_class

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

private

Object name to class name association.

Definition at line 255 of file Factory.h.

Referenced by associatedClassName(), and associateNameToClass().

_name_to_line

FileLineInfoMap Factory::_name_to_line

private

Definition at line 252 of file Factory.h.

Referenced by getLineInfo(), and reg().

_name_to_object

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

private

Storage for pointers to the object registry entry.

Definition at line 250 of file Factory.h.

Referenced by createTempl(), getValidParams(), initialize(), isRegistered(), reg(), and registeredObjects().

_objects_by_label

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

private

set<label/appname, objectname> used to track if an object previously added is being added again - which is okay/allowed, while still allowing us to detect/reject cases of duplicate object name registration where the label/appname is not identical.

Definition at line 275 of file Factory.h.

Referenced by reg().

_registerable_objects

std::set<std::string> Factory::_registerable_objects

private

The list of objects that may be registered.

Definition at line 264 of file Factory.h.

Referenced by reg(), and restrictRegisterableObjects().

---

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

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