Nektar::LibUtilities::NekFactory< tKey, tBase, tParam > Class Template Reference

Provides a generic Factory class. More...

#include <NekFactory.hpp>

Classes
struct	ModuleEntry
	Define a struct to hold the information about a module. More...

Public Types
typedef std::less< tKey >	tPredicator
	Comparison predicator of key. More...
typedef std::shared_ptr< tBase >	tBaseSharedPtr
	Shared pointer to an object of baseclass type. More...
typedef std::function< tBaseSharedPtr(tParam...)>	CreatorFunction
	CreatorFunction type which takes parameter and returns base class shared pointer. More...
typedef std::map< tKey, ModuleEntry, tPredicator >	TMapFactory
	Factory map between key and module data. More...

Public Member Functions
	NekFactory ()=default
tBaseSharedPtr	CreateInstance (tKey idKey, tParam... args)
	Create an instance of the class referred to by idKey. More...
tKey	RegisterCreatorFunction (tKey idKey, CreatorFunction classCreator, std::string pDesc="")
	Register a class with the factory. More...
bool	ModuleExists (tKey idKey)
	Checks if a particular module is available. More...
void	PrintAvailableClasses (std::ostream &pOut=std::cout)
	Prints the available classes to stdout. More...
std::string	GetClassDescription (tKey idKey)
	Returns the description of a class. More...

Protected Member Functions
TMapFactory *	getMapFactory ()
	Ensure the factory's map is created. More...

Private Member Functions
	NekFactory (const NekFactory &rhs)=delete
NekFactory &	operator= (const NekFactory &rhs)=delete

Private Attributes
TMapFactory	mMapFactory

Detailed Description

template<typename tKey, typename tBase, typename... tParam>
class Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >

Provides a generic Factory class.

Implements a generic object factory. Class-types which use an arbitrary number of parameters may be used via C++ variadic templating.

To allow a class to be instantiated by the factory, the following are required in each class definition (in the case of a single parameter):

static [baseclass]* create([paramtype1] &P) {
   return new [derivedclass](P);
}
static std::string className;

and outside the class definition in the implementation:

std::string [derivedclass]::className
   = Factory<std::string,[baseclass],[paramtype1]>::
       RegisterCreatorFunction("[derivedclass]",
                           [derivedclass]::create,"Description");

The assignment of the static variable className is done through the call to RegisterCreatorFunction, which registers the class with the factory prior to the start of the main() routine.

To create an instance of a derived class, for instance:

[baseclass]* var_name =
   Factory<std::string,[baseclass],[paramtype1]>
           ::CreateInstance("[derivedclass]",Param1);

Definition at line 104 of file NekFactory.hpp.

Member Typedef Documentation

CreatorFunction

template<typename tKey , typename tBase , typename... tParam>

typedef std::function<tBaseSharedPtr(tParam...)> Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreatorFunction

CreatorFunction type which takes parameter and returns base class shared pointer.

Definition at line 113 of file NekFactory.hpp.

tBaseSharedPtr

template<typename tKey , typename tBase , typename... tParam>

typedef std::shared_ptr<tBase> Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::tBaseSharedPtr

Shared pointer to an object of baseclass type.

Definition at line 110 of file NekFactory.hpp.

TMapFactory

template<typename tKey , typename tBase , typename... tParam>

typedef std::map<tKey, ModuleEntry, tPredicator> Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::TMapFactory

Factory map between key and module data.

Definition at line 130 of file NekFactory.hpp.

tPredicator

template<typename tKey , typename tBase , typename... tParam>

typedef std::less<tKey> Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::tPredicator

Comparison predicator of key.

Definition at line 108 of file NekFactory.hpp.

Constructor & Destructor Documentation

NekFactory() [1/2]

template<typename tKey , typename tBase , typename... tParam>

Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::NekFactory ( )

default

NekFactory() [2/2]

template<typename tKey , typename tBase , typename... tParam>

Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::NekFactory ( const NekFactory< tKey, tBase, tParam > &  rhs )

privatedelete

Member Function Documentation

CreateInstance()

template<typename tKey , typename tBase , typename... tParam>

tBaseSharedPtr Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance ( tKey  idKey, tParam...  args  )

inline

Create an instance of the class referred to by idKey.

Searches the factory's map for the given key and returns a shared base class pointer to a new instance of the associated class.

Parameters

idKey	Key of class to create.
args	Parameter to pass to class constructor.

Returns

Base class pointer to new instance.

Definition at line 144 of file NekFactory.hpp.

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        ReadLock vReadLock(m_mutex);
#endif
 
        // Now try and find the key in the map.
        auto it = getMapFactory()->find(idKey);
 
        // If successful, check the CreatorFunction is defined and
        // create a new instance of the class.
        if (it != getMapFactory()->end())
        {
            ModuleEntry *tmp = &(it->second);
#ifdef NEKTAR_USE_THREAD_SAFETY
            vReadLock.unlock();
#endif
 
            if (tmp->m_func)
            {
                try
                {
                    return tmp->m_func(args...);
                }
                catch (const std::string &s)
                {
                    std::stringstream errstr;
                    errstr << "Unable to create module: " << idKey << "\n";
                    errstr << s;
                    NEKERROR(ErrorUtil::efatal, errstr.str());
                }
            }
        }
 
        // If we get this far, the key doesn't exist, so throw an error.
        std::stringstream errstr;
        errstr << "No such module: " << idKey << std::endl;
        PrintAvailableClasses(errstr);
        NEKERROR(ErrorUtil::efatal, errstr.str());
        return tBaseSharedPtr();
    }

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::ModuleEntry::m_func, NEKERROR, and Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::PrintAvailableClasses().

Referenced by Nektar::SolverUtils::Advection3DHomogeneous1D::Advection3DHomogeneous1D(), Nektar::ArtificialDiffusion::ArtificialDiffusion(), Nektar::Collections::BwdTrans_MatrixFree::BwdTrans_MatrixFree(), Nektar::CompressibleSolver::CompressibleSolver(), Nektar::LibUtilities::SessionReader::CreateComm(), Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::Thread::ThreadMaster::CreateInstance(), Nektar::SolverUtils::FilterFieldConvert::CreateModules(), Nektar::MultiRegions::GlobalLinSys::CreatePrecon(), Nektar::LinearisedAdvection::DFT(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::Diffusion3DHomogeneous1D(), Nektar::VortexWaveInteraction::ExecuteRoll(), Nektar::VortexWaveInteraction::ExecuteStreak(), Nektar::MultiRegions::ExpListHomogeneous1D::ExpListHomogeneous1D(), Nektar::MultiRegions::ExpListHomogeneous2D::ExpListHomogeneous2D(), Nektar::MultiRegions::ExpList::ExtractCoeffsFromFile(), Field_Init(), Nektar::FieldUtils::Field::FieldIOForFile(), Nektar::MultiRegions::ExpList::GenGlobalBndLinSys(), Nektar::MultiRegions::ExpList::GenGlobalLinSys(), Nektar::Collections::Helmholtz_MatrixFree::Helmholtz_MatrixFree(), Nektar::LibUtilities::Import(), Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::Collections::Collection::Initialise(), Nektar::ForcingMovingBody::InitialiseCableModel(), Nektar::CFSImplicit::InitialiseNonlinSysSolver(), Nektar::NavierStokesCFE::InitObject_Explicit(), Nektar::Collections::IProductWRTBase_MatrixFree::IProductWRTBase_MatrixFree(), Nektar::Collections::IProductWRTDerivBase_MatrixFree::IProductWRTDerivBase_MatrixFree(), Nektar::GlobalMapping::Mapping::Load(), main(), Module_Create(), Nektar::LibUtilities::NekNonlinSys::NekNonlinSys(), Nektar::Collections::PhysDeriv_MatrixFree::PhysDeriv_MatrixFree(), Nektar::SpatialDomains::MeshGraph::Read(), Nektar::SpatialDomains::MeshPartition::ReadExpansions(), Nektar::UpwindPulseSolver::RiemannSolverUpwind(), SessionReader_CreateInstance(), Nektar::SolverUtils::DriverParallelInTime::SetParallelInTimeEquationSystem(), Nektar::PulseWavePropagation::SetPulseWaveBoundaryConditions(), Nektar::VelocityCorrectionScheme::SetUpExtrapolation(), Nektar::UnsteadyAdvectionDiffusion::SetUpSubSteppingTimeIntegration(), Nektar::Stimulus::Stimulus(), Diffusion::TimeIntegrate(), Nektar::MultiRegions::PreconditionerLinearWithBlock::v_InitObject(), Nektar::MultiRegions::PreconditionerLinearWithDiag::v_InitObject(), Nektar::MultiRegions::PreconditionerLinearWithLowEnergy::v_InitObject(), Nektar::PulseWavePropagation::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LEE::v_InitObject(), Nektar::CFLtester::v_InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyInviscidBurger::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), Nektar::CompressibleFlowSystem::v_InitObject(), Nektar::LinearSWE::v_InitObject(), Nektar::NonlinearPeregrine::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), Nektar::DiffusionLDGNS::v_InitObject(), Nektar::SolverUtils::Driver::v_InitObject(), Nektar::FieldUtils::OutputFld::v_OutputFromData(), Nektar::FieldUtils::OutputFld::v_OutputFromExp(), Nektar::SpatialDomains::MeshGraphHDF5::v_PartitionMesh(), Nektar::SpatialDomains::MeshGraphXml::v_PartitionMesh(), Nektar::FieldUtils::ProcessPointDataToFld::v_Process(), Nektar::MultiRegions::GlobalLinSysIterativeFull::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_SolveLinearSystem(), Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration(), Nektar::VariableConverter::VariableConverter(), Nektar::VortexWaveInteraction::VortexWaveInteraction(), Nektar::LibUtilities::Write(), and Nektar::FieldUtils::OutputFileBase::WriteFile().

GetClassDescription()

template<typename tKey , typename tBase , typename... tParam>

std::string Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::GetClassDescription ( tKey  idKey )

inline

Returns the description of a class.

Definition at line 257 of file NekFactory.hpp.

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        ReadLock vReadLock(m_mutex);
#endif
 
        // Now try and find the key in the map.
        auto it = getMapFactory()->find(idKey);
 
        std::stringstream errstr;
        errstr << "No such module: " << idKey << std::endl;
        ASSERTL0(it != getMapFactory()->end(), errstr.str());
        return it->second.m_desc;
    }

References ASSERTL0, and Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory().

getMapFactory()

template<typename tKey , typename tBase , typename... tParam>

TMapFactory * Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory ( )

inlineprotected

Ensure the factory's map is created.

Returns

The factory's map.

Definition at line 277 of file NekFactory.hpp.

    {
        return &mMapFactory;
    }

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::mMapFactory.

Referenced by Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::GetClassDescription(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::ModuleExists(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::PrintAvailableClasses(), and Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::RegisterCreatorFunction().

ModuleExists()

template<typename tKey , typename tBase , typename... tParam>

bool Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::ModuleExists ( tKey  idKey )

inline

Checks if a particular module is available.

Definition at line 213 of file NekFactory.hpp.

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        ReadLock vReadLock(m_mutex);
#endif
 
        // Now try and find the key in the map.
        auto it = getMapFactory()->find(idKey);
 
        if (it != getMapFactory()->end())
        {
            return true;
        }
        return false;
    }

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory().

operator=()

template<typename tKey , typename tBase , typename... tParam>

NekFactory & Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::operator= ( const NekFactory< tKey, tBase, tParam > &  rhs )

privatedelete

PrintAvailableClasses()

template<typename tKey , typename tBase , typename... tParam>

void Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::PrintAvailableClasses ( std::ostream &  pOut = std::cout )

inline

Prints the available classes to stdout.

Definition at line 232 of file NekFactory.hpp.

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        ReadLock vReadLock(m_mutex);
#endif
 
        pOut << std::endl << "Available classes: " << std::endl;
        for (auto &it : *getMapFactory())
        {
            pOut << "  " << it.first;
            if (it.second.m_desc != "")
            {
                pOut << ":" << std::endl
                     << "    " << it.second.m_desc << std::endl;
            }
            else
            {
                pOut << std::endl;
            }
        }
    }

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory().

Referenced by Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), and main().

RegisterCreatorFunction()

template<typename tKey , typename tBase , typename... tParam>

tKey Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::RegisterCreatorFunction ( tKey  idKey, CreatorFunction  classCreator, std::string  pDesc = ""  )

inline

Register a class with the factory.

This function is called by each class in a static context (prior to the execution of main()) and creates an entry for the class in the factory's map.

Parameters

idKey	Key used to reference the class.
classCreator	Function to call to create an instance of this class.
pDesc	Optional description of class.

Returns

The given key idKey.

Definition at line 198 of file NekFactory.hpp.

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        WriteLock vWriteLock(m_mutex);
#endif
 
        ModuleEntry e(classCreator, pDesc);
        getMapFactory()->insert(std::pair<tKey, ModuleEntry>(idKey, e));
        return idKey;
    }

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory().

Referenced by Module_Register().

Member Data Documentation

mMapFactory

template<typename tKey , typename tBase , typename... tParam>

TMapFactory Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::mMapFactory

private

Definition at line 286 of file NekFactory.hpp.

Referenced by Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::getMapFactory().