spades::Factory< Base, Args > Struct Template Reference

#include <Factory.H>

Classes
struct	Register
	Class to handle registration of subclass for runtime selection. More...

Public Member Functions
virtual	~Factory ()=default

Static Public Member Functions
static std::unique_ptr< Base >	create (const std::string &key, Args... args)
static void	print (std::ostream &os)

Public Attributes
friend	Base

Private Types
using	CreatorFunc = std::unique_ptr<Base> (*)(Args...)
using	LookupTable = std::unordered_map<std::string, CreatorFunc>

Private Member Functions
	Factory ()=default

Static Private Member Functions
static void	key_exists_or_error (const std::string &key)
static LookupTable &	table ()
	Lookup table containing all registered instances.

Detailed Description

template<class Base, class... Args>
struct spades::Factory< Base, Args >

Runtime selection of options based on string keyword lookup

This is lifted straight from AMR-wind, https://github.com/Exawind/amr-wind

Factory provides an automated way to register subclasses that can be instantiated during runtime using string based lookups. The facility mimics the runTimeSelectionTable in OpenFOAM and the current structure is adapted from http://www.nirfriedman.com/2018/04/29/unforgettable-factory/

The usage is described using the following example from code. We would like to support creation of a turbulence model based on user inputs that are read from a file. We will create a base class TurbulenceModel that defines the API for the turbulence model and how it interacts with the rest of the code. Then new models, e.g., Smagorinsky, k-Omega SST/SAS, etc., are added as subclasses to this instance.

 // Create a base class that can be used to register and create instances
 //
 // The template arguments are the classname for CRTP and types of additional
 // arguments to be passed to the constructor of the object
 class TurbulenceModel : public Factory<TurbulenceModel, const CFDSim&>
 {
      // Define a base identifier string for debugging purposes
      static const std::string base_identifier() { return "TurbulenceModel";
}
 
      // Define API as appropriate here
 };
 
 // Define a subclass
 // Instead of using the base class we use Base::Register to allow
registration class Smagorinsky : public
TurbulenceModel::Register<Smagorinsky>
 {
      // This is the keyword that is used to lookup and create this instance
      static const std::string identifier() { return "Smagorinsky"; }
 
      // Model implementation here
 };
 
 // To create a turbulence model instance
 auto sim = CFDSim(mesh);
 // tmodel is a std::unique_ptr<TurbulenceModel> instance
 auto tmodel = TurbulenceModel::create("Smagorinsky", sim);

Template Parameters

Base	base class (e.g., Physics)
Args	Arguments types to be passed to the constructor during instantiation

Member Typedef Documentation

CreatorFunc

template<class Base , class... Args>

using spades::Factory< Base, Args >::CreatorFunc = std::unique_ptr<Base> (*)(Args...)

private

LookupTable

template<class Base , class... Args>

using spades::Factory< Base, Args >::LookupTable = std::unordered_map<std::string, CreatorFunc>

private

Constructor & Destructor Documentation

~Factory()

template<class Base , class... Args>

virtual spades::Factory< Base, Args >::~Factory ( )

virtualdefault

Factory()

template<class Base , class... Args>

spades::Factory< Base, Args >::Factory ( )

privatedefault

Member Function Documentation

create()

template<class Base , class... Args>

static std::unique_ptr< Base > spades::Factory< Base, Args >::create ( const std::string & key, Args... args )

inlinestatic

Create an instance of the concrete subclass based on the runtime keyword

Parameters

key	Unique identifier used to lookup subclass instance
args	Arguments to the constructor of the subclass

    {
        key_exists_or_error(key);
        auto ptr = table().at(key)(std::forward<Args>(args)...);
        amrex::Print() << "Creating " << Base::base_identifier()
                       << " instance: " << key << std::endl;
        return ptr;
    }

Here is the call graph for this function:

key_exists_or_error()

template<class Base , class... Args>

static void spades::Factory< Base, Args >::key_exists_or_error ( const std::string & key )

inlinestaticprivate

Check if the keyword exists in table or print diagnostic message and abort

    {
        const auto& tbl = table();
        if (tbl.find(key) == tbl.end()) {
            // Print valid options
            if (amrex::ParallelDescriptor::IOProcessor()) {
                print(std::cout);
            }
            // Quit with error
            amrex::Abort(
                "In " + Base::base_identifier() +
                " cannot find instance: " + key);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

print()

template<class Base , class... Args>

static void spades::Factory< Base, Args >::print ( std::ostream & os )

inlinestatic

Print a list of the valid subclasses registered to this base instance

Parameters

os	Valid output stream

    {
        const auto& tbl = table();
        os << Base::base_identifier() << " " << tbl.size() << std::endl;
        for (const auto& it : tbl) {
            os << " - " << it.first << std::endl;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

table()

template<class Base , class... Args>

static LookupTable & spades::Factory< Base, Args >::table ( )

inlinestaticprivate

Lookup table containing all registered instances.

    {
        static LookupTable tbl;
        return tbl;
    }

Here is the caller graph for this function:

Member Data Documentation

Base

template<class Base , class... Args>

friend spades::Factory< Base, Args >::Base

---

The documentation for this struct was generated from the following file:

• /home/runner/work/spades/spades/Source/Factory.H