AlgorithmManager.h

Go to the documentation of this file.

#ifndef GAUDISVC_ALGORITHMMANAGER_H
#define GAUDISVC_ALGORITHMMANAGER_H

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

// 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