#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 More...

Public Member Functions
bool	Register (const std::string &algType, Creator creator)
	Register creator function for algorithm type. More...

ConfigurableAlg *	create (const std::string &algType, const std::string &algName)
	Create algorithm of given type and name. More...

ConfigurableAlg *	algorithm (const std::string &algName)
	Retrieve algorithm by name. More...

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

void	printAlgorithmNames () const

Static Public Member Functions
static const AlgFactory &	instance ()
	read-only access More...

static AlgFactory &mutable_instance	ATLAS_NOT_THREAD_SAFE ()
	non-const access More...

Private Member Functions
	AlgFactory ()=default

	AlgFactory (const AlgFactory &)=delete
	no copy More...

AlgFactory &	operator= (const AlgFactory &)=delete
	no assign More...

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()

static 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