AlgorithmManager.h

Go to the documentation of this file.

#ifndef GAUDISVC_ALGORITHMMANAGER_H
#define GAUDISVC_ALGORITHMMANAGER_H

// Include files
#include "GaudiKernel/ComponentManager.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IStateful.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/SmartIF.h"
#include <map>
#include <string>
#include <vector>

// Forward declarations
class ISvcLocator;
class IMessageSvc;

class AlgorithmManager : public extends<ComponentManager, IAlgManager>
{
public:
  struct AlgorithmItem final {
    AlgorithmItem( IAlgorithm* s, bool managed = false ) : algorithm( s ), managed( managed ) {}
    SmartIF<IAlgorithm> algorithm;
    bool managed;
    inline bool operator==( const std::string& name ) const { return algorithm->name() == name; }
    inline bool operator==( const IAlgorithm* ptr ) const { return algorithm.get() == ptr; }
  };

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

  AlgorithmManager( IInterface* iface );
  ~AlgorithmManager() override = default;

  StatusCode addAlgorithm( IAlgorithm* alg ) override;
  StatusCode removeAlgorithm( IAlgorithm* alg ) override;
  StatusCode createAlgorithm( const std::string& algtype, const std::string& algname, IAlgorithm*& algorithm,
                              bool managed = false, bool checkIfExists = true ) override;

  bool existsAlgorithm( const std::string& name ) const override;
  const std::vector<IAlgorithm*>& getAlgorithms() const override;

  StatusCode initialize() override;
  StatusCode start() override;
  StatusCode stop() override;
  StatusCode finalize() override;

  StatusCode reinitialize() override;
  StatusCode restart() override;

  const std::string& name() const override
  {
    static const std::string _name = "AlgorithmManager";
    return _name;
  }

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

  AlgTypeAliasesMap& typeAliases() { return m_algTypeAliases; }
  const AlgTypeAliasesMap& typeAliases() const { return m_algTypeAliases; }

private:
  std::vector<AlgorithmItem> m_algs; 

  mutable std::vector<IAlgorithm*> m_listOfPtrs;

  AlgTypeAliasesMap m_algTypeAliases;
};
#endif // GAUDISVC_ALGORITHMFACTORY_H