#include <AlgFactory.h>

Collaboration diagram for TCS::AlgFactory:

Public Types
typedef std::unique_ptr< ConfigurableAlg >(*	Creator) (const std::string &methodName)
	function type to create an algorithm

Public Member Functions
bool	Register (const std::string &algType, Creator creator)
	Register creator function for algorithm type.
ConfigurableAlg *	create (const std::string &algType, const std::string &algName)
	Create algorithm of given type and name.
ConfigurableAlg *	algorithm (const std::string &algName)
	Retrieve algorithm by name.
std::vector< std::string >	getAllClassNames () const
void	printAlgorithmNames () const

Static Public Member Functions
static const AlgFactory &	instance ()
	read-only access
static AlgFactory &mutable_instance	ATLAS_NOT_THREAD_SAFE ()
	non-const access

Private Member Functions
	AlgFactory ()=default
	AlgFactory (const AlgFactory &)=delete
	no copy
AlgFactory &	operator= (const AlgFactory &)=delete
	no assign

Private Attributes
std::map< std::string, Creator >	m_callMap
std::map< std::string, std::unique_ptr< TCS::ConfigurableAlg > >	m_algs

Detailed Description

Definition at line 16 of file AlgFactory.h.

Member Typedef Documentation

◆ Creator

typedef std::unique_ptr< ConfigurableAlg >(* TCS::AlgFactory::Creator) (const std::string &methodName)

function type to create an algorithm

Definition at line 19 of file AlgFactory.h.

Constructor & Destructor Documentation

◆ AlgFactory() [1/2]

TCS::AlgFactory::AlgFactory ( )

privatedefault

◆ AlgFactory() [2/2]

TCS::AlgFactory::AlgFactory ( const AlgFactory & )

privatedelete

no copy

Member Function Documentation

◆ algorithm()

TCS::ConfigurableAlg * AlgFactory< ConcreteAlgorithm >::algorithm ( const std::string & algName )

Retrieve algorithm by name.

Definition at line 66 of file AlgFactory.cxx.

                                                  {
   auto findRes = m_algs.find(algName);
 
   if(findRes == m_algs.end())
      return nullptr;
 
   return findRes->second.get();
}

◆ ATLAS_NOT_THREAD_SAFE()

AlgFactory &mutable_instance TCS::AlgFactory::ATLAS_NOT_THREAD_SAFE ( )

static

non-const access

◆ create()

TCS::ConfigurableAlg * AlgFactory< ConcreteAlgorithm >::create	(	const std::string &	algType,
		const std::string &	algName )

Create algorithm of given type and name.

Definition at line 21 of file AlgFactory.cxx.

                                                                                                {
 
   if( algorithm(algName) ) {
      TCS_EXCEPTION("AlgFactory: algorithm " << algName << " already exists. Serious configuration error.")
   }
 
   // find creator function
   const auto& it = m_callMap.find(algType);
   
   // handle unknown algorithm request
   if (it == m_callMap.end()) {
      std::cout << "Registered algorithms are:" << std::endl;
      for(const auto & x: m_callMap)
         std::cout << "   " << x.first << std::endl;
      TCS_EXCEPTION("AlgFactory: trying to instantiate algorithm of type " << algType << " with name " << algName << ", but it has not been registered.");
   }
 
   auto createdAlg = (it->second)(algName);
   auto [itr,inserted] = m_algs.emplace(algName, std::move(createdAlg));
 
   return itr->second.get();
}

◆ getAllClassNames()

std::vector< std::string > AlgFactory< ConcreteAlgorithm >::getAllClassNames ( ) const

Definition at line 56 of file AlgFactory.cxx.

                                      {
   std::vector<std::string> classNames;
   classNames.reserve(m_callMap.size());
   for (const auto& [key, _] : m_callMap) {
      classNames.push_back(key);
   }
   return classNames;
}

◆ instance()

const TCS::AlgFactory & AlgFactory< ConcreteAlgorithm >::instance ( )

static

read-only access

Definition at line 7 of file AlgFactory.cxx.

{
   static const TCS::AlgFactory factory;
   return factory;
}

◆ operator=()

AlgFactory & TCS::AlgFactory::operator= ( const AlgFactory & )

privatedelete

no assign

◆ printAlgorithmNames()

void AlgFactory< ConcreteAlgorithm >::printAlgorithmNames ( ) const

Definition at line 77 of file AlgFactory.cxx.

                                         {
   for(const auto& [name, alg] : m_algs) {
      std::cout << name << " --> " << alg->fullname() << std::endl;
   }
}

◆ Register()

bool AlgFactory< ConcreteAlgorithm >::Register	(	const std::string &	algType,
		Creator	creator )

Register creator function for algorithm type.

Definition at line 46 of file AlgFactory.cxx.

                                                                   {
   const auto& [itr, inserted] = m_callMap.emplace(algType, creator);
   // registers a algorithm creator function under the algorithm class name
   if (!inserted) {
      TCS_EXCEPTION ("TCS::AlgFactory: registration of algorithm " << algType << " failed since it already exists");
   }
   return inserted;
}

Member Data Documentation

◆ m_algs

std::map<std::string, std::unique_ptr<TCS::ConfigurableAlg> > TCS::AlgFactory::m_algs

private

Definition at line 42 of file AlgFactory.h.

◆ m_callMap

std::map<std::string, Creator> TCS::AlgFactory::m_callMap