AlgorithmManager Class Reference

The AlgorithmManager class is in charge of the creation of concrete instances of Algorithms. More...

#include <src/ApplicationMgr/AlgorithmManager.h>

Inheritance diagram for AlgorithmManager:

Collaboration diagram for AlgorithmManager:

Classes
struct	AlgorithmItem

Public Types
typedef std::map< std::string, std::string >	AlgTypeAliasesMap
	typedefs and classes More...
Public Types inherited from extends< BASE, Interfaces >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
Public Types inherited from extend_interfaces< Interfaces...>
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Public Member Functions
	AlgorithmManager (IInterface *iface)
	default creator More...
	~AlgorithmManager () override=default
	virtual destructor More...
StatusCode	addAlgorithm (IAlgorithm *alg) override
	implementation of IAlgManager::addAlgorithm More...
StatusCode	removeAlgorithm (IAlgorithm *alg) override
	implementation of IAlgManager::removeAlgorithm More...
StatusCode	createAlgorithm (const std::string &algtype, const std::string &algname, IAlgorithm *&algorithm, bool managed=false, bool checkIfExists=true) override
	implementation of IAlgManager::createAlgorithm More...
bool	existsAlgorithm (const std::string &name) const override
	implementation of IAlgManager::existsAlgorithm More...
const std::vector< IAlgorithm * > &	getAlgorithms () const override
	implementation of IAlgManager::getAlgorithms More...
StatusCode	initialize () override
	Initialization (from CONFIGURED to INITIALIZED). More...
StatusCode	start () override
	Start (from INITIALIZED to RUNNING). More...
StatusCode	stop () override
	Stop (from RUNNING to INITIALIZED). More...
StatusCode	finalize () override
	Finalize (from INITIALIZED to CONFIGURED). More...
StatusCode	reinitialize () override
	Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED). More...
StatusCode	restart () override
	Initialization (from RUNNING to RUNNING, via INITIALIZED). More...
const std::string &	name () const override
	Return the name of the manager (implementation of INamedInterface) More...
SmartIF< IAlgorithm > &	algorithm (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override
AlgTypeAliasesMap &	typeAliases ()
const AlgTypeAliasesMap &	typeAliases () const
Public Member Functions inherited from extends< BASE, Interfaces >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...
	~extend_interfaces () override=default
	Virtual destructor. More...

Private Attributes
std::vector< AlgorithmItem >	m_algs
	algorithms maintained by AlgorithmManager More...
std::vector< IAlgorithm * >	m_listOfPtrs
	List of pointers to the know services used to implement getAlgorithms() More...
AlgTypeAliasesMap	m_algTypeAliases

Detailed Description

The AlgorithmManager class is in charge of the creation of concrete instances of Algorithms.

The ApplicationMgr delegates the creation and bookkeeping of algorithms to the algorithm factory. In order to be able to create algorithms from which it does not know the concrete type it requires that the algorithm has been declared in one of 3 possible ways: an abstract static creator function, a dynamic link library or an abstract factory reference.

Author

Pere Mato

Definition at line 31 of file AlgorithmManager.h.

Member Typedef Documentation

typedef std::map<std::string, std::string> AlgorithmManager::AlgTypeAliasesMap

typedefs and classes

Definition at line 48 of file AlgorithmManager.h.

Constructor & Destructor Documentation

AlgorithmManager::AlgorithmManager

(

IInterface *

iface

)

default creator

Definition at line 18 of file AlgorithmManager.cpp.

                                                         :
  base_class(application, IAlgorithm::interfaceID())
{
  addRef(); // Initial count set to 1
}

AlgorithmManager::~AlgorithmManager ( )

overridedefault

virtual destructor

Member Function Documentation

StatusCode AlgorithmManager::addAlgorithm ( IAlgorithm *  alg )

override

implementation of IAlgManager::addAlgorithm

Definition at line 25 of file AlgorithmManager.cpp.

                                                         {
  m_algs.push_back(alg);
  return StatusCode::SUCCESS;
}

SmartIF< IAlgorithm > & AlgorithmManager::algorithm ( const Gaudi::Utils::TypeNameString &  typeName, const bool  createIf = true  )

override

Definition at line 103 of file AlgorithmManager.cpp.

                                                                                                              {
  auto it = std::find(m_algs.begin(), m_algs.end(), typeName.name());
  if (it != m_algs.end()) { // found
    return it->algorithm;
  }
  if (createIf) {
    IAlgorithm* alg;
    if (createAlgorithm(typeName.type(), typeName.name(), alg, true).isSuccess()) {
      return algorithm(typeName, false);
    }
  }
  return no_algorithm;
}

StatusCode AlgorithmManager::createAlgorithm ( const std::string &  algtype, const std::string &  algname, IAlgorithm *&  algorithm, bool  managed = false, bool  checkIfExists = true  )

override

implementation of IAlgManager::createAlgorithm

Definition at line 41 of file AlgorithmManager.cpp.

{
  // Check is the algorithm is already existing
  if (checkIfExists) {
    if( existsAlgorithm( algname ) ) {
      // return an error because an algorithm with that name already exists
      return StatusCode::FAILURE;
    }
  }
  std::string actualalgtype(algtype);
  // a '\' in front of the type name prevents alias replacement
  if ((actualalgtype.size() > 8) && (actualalgtype.compare(0, 8,"unalias:") == 0)) {
    actualalgtype = actualalgtype.substr(8);
  } else {
    auto typeAlias = m_algTypeAliases.find(algtype);
    if (typeAlias != m_algTypeAliases.end()) {
      actualalgtype = typeAlias->second;
    }
  }
  algorithm = Algorithm::Factory::create(actualalgtype, algname, serviceLocator().get());
  if ( !algorithm )  {
      this->error() << "Algorithm of type " << actualalgtype
                    << " is unknown (No factory available)." << endmsg;
#ifndef _WIN32
      errno = 0xAFFEDEAD; // code used by Gaudi for library load errors: forces getLastErrorString do use dlerror (on Linux)
#endif
      std::string err = System::getLastErrorString();
      if (! err.empty()) this->error() << err << endmsg;
      this->error() << "More information may be available by setting the global jobOpt \"PluginDebugLevel\" to 1" << endmsg;
      return StatusCode::FAILURE;
  }
  // Check the compatibility of the version of the interface obtained
  if( !isValidInterface(algorithm) ) {
    fatal() << "Incompatible interface IAlgorithm version for " << actualalgtype << endmsg;
    return StatusCode::FAILURE;
  }
  m_algs.emplace_back(algorithm, managed);
  // let the algorithm know its type
  algorithm->setType(algtype);
  // this is needed to keep the reference count correct, since isValidInterface(algorithm)
  // implies an increment of the counter by 1
  algorithm->release();
  StatusCode rc;
  if ( managed ) {
    // Bring the created algorithm to the same state of the ApplicationMgr
    if (FSMState() >= Gaudi::StateMachine::INITIALIZED) {
      rc = algorithm->sysInitialize();
      if (rc.isSuccess() && FSMState() >= Gaudi::StateMachine::RUNNING) {
        rc = algorithm->sysStart();
      }
    }
    if ( !rc.isSuccess() )  {
      this->error() << "Failed to initialize algorithm: [" << algname << "]" << endmsg;
    }
  }
  return rc;
}

bool AlgorithmManager::existsAlgorithm ( const std::string &  name ) const

override

implementation of IAlgManager::existsAlgorithm

Definition at line 118 of file AlgorithmManager.cpp.

                                                                  {
  return  m_algs.end() != std::find(m_algs.begin(), m_algs.end(), name);
}

StatusCode AlgorithmManager::finalize ( )

override

Finalize (from INITIALIZED to CONFIGURED).

Definition at line 165 of file AlgorithmManager.cpp.

                                      {
  StatusCode rc;
  auto it = m_algs.begin();
  while (it != m_algs.end()){ // finalize and remove from the list the managed algorithms
    if (it->managed) {
      rc = it->algorithm->sysFinalize();
      if( rc.isFailure() ) return rc;
      it = m_algs.erase(it);
    } else {
      ++it;
    }
  }
  return rc;
}

const std::vector< IAlgorithm * > & AlgorithmManager::getAlgorithms ( ) const

override

implementation of IAlgManager::getAlgorithms

Definition at line 123 of file AlgorithmManager.cpp.

{
  m_listOfPtrs.clear();
  m_listOfPtrs.reserve(m_algs.size());
  std::transform( std::begin(m_algs), std::end(m_algs),
                  std::back_inserter(m_listOfPtrs),
                  [](const AlgorithmItem& alg) {
                      return const_cast<IAlgorithm*>(alg.algorithm.get());
                  } );
  return m_listOfPtrs;
}

StatusCode AlgorithmManager::initialize ( )

override

Initialization (from CONFIGURED to INITIALIZED).

Definition at line 135 of file AlgorithmManager.cpp.

                                        {
  StatusCode rc;
  for (auto& it : m_algs ) {
    if (!it.managed) continue;
    rc = it.algorithm->sysInitialize();
    if ( rc.isFailure() ) return rc;
  }
  return rc;
}

const std::string& AlgorithmManager::name ( ) const

inlineoverride

Return the name of the manager (implementation of INamedInterface)

Definition at line 83 of file AlgorithmManager.h.

                                         {
    static const std::string _name = "AlgorithmManager";
    return _name;
  }

StatusCode AlgorithmManager::reinitialize ( )

override

Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

Definition at line 180 of file AlgorithmManager.cpp.

                                          {
  StatusCode rc;
  for (auto& it : m_algs ) {
    if (!it.managed) continue;
    rc = it.algorithm->sysReinitialize();
    if( rc.isFailure() ){
      this->error() << "Unable to re-initialize algorithm: " << it.algorithm->name() << endmsg;
      return rc;
    }
  }
  return rc;
}

StatusCode AlgorithmManager::removeAlgorithm ( IAlgorithm *  alg )

override

implementation of IAlgManager::removeAlgorithm

Definition at line 31 of file AlgorithmManager.cpp.

                                                            {
  auto it = std::find(m_algs.begin(), m_algs.end(), alg);
  if (it != m_algs.end()) {
    m_algs.erase(it);
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

StatusCode AlgorithmManager::restart ( )

override

Initialization (from RUNNING to RUNNING, via INITIALIZED).

Definition at line 193 of file AlgorithmManager.cpp.

                                     {
  StatusCode rc;
  for (auto& it : m_algs ) {
    if (!it.managed) continue;
    rc = it.algorithm->sysRestart();
    if( rc.isFailure() ){
      this->error() << "Unable to re-initialize algorithm: " << it.algorithm->name() << endmsg;
      return rc;
    }
  }
  return rc;
}

StatusCode AlgorithmManager::start ( )

override

Start (from INITIALIZED to RUNNING).

Definition at line 145 of file AlgorithmManager.cpp.

                                   {
  StatusCode rc;
  for (auto& it : m_algs ) {
    if (!it.managed) continue;
    rc = it.algorithm->sysStart();
    if ( rc.isFailure() ) return rc;
  }
  return rc;
}

StatusCode AlgorithmManager::stop ( )

override

Stop (from RUNNING to INITIALIZED).

Definition at line 155 of file AlgorithmManager.cpp.

                                  {
  StatusCode rc;
  for (auto& it : m_algs) {
    if (!it.managed) continue;
    rc = it.algorithm->sysStop();
    if ( rc.isFailure() ) return rc;
  }
  return rc;
}

AlgTypeAliasesMap& AlgorithmManager::typeAliases ( )

inline

Definition at line 90 of file AlgorithmManager.h.

{ return m_algTypeAliases; }

const AlgTypeAliasesMap& AlgorithmManager::typeAliases ( ) const

inline

Definition at line 91 of file AlgorithmManager.h.

{ return m_algTypeAliases; }

Member Data Documentation

std::vector<AlgorithmItem> AlgorithmManager::m_algs

private

algorithms maintained by AlgorithmManager

Definition at line 94 of file AlgorithmManager.h.

AlgTypeAliasesMap AlgorithmManager::m_algTypeAliases

private

Definition at line 99 of file AlgorithmManager.h.

std::vector<IAlgorithm*> AlgorithmManager::m_listOfPtrs

mutableprivate

List of pointers to the know services used to implement getAlgorithms()

Definition at line 97 of file AlgorithmManager.h.

---

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

• GaudiCoreSvc/src/ApplicationMgr/AlgorithmManager.h
• GaudiCoreSvc/src/ApplicationMgr/AlgorithmManager.cpp