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 <list>
#include <map>

// Forward declarations
class ISvcLocator;
class IMessageSvc;

class AlgorithmManager : public extends1<ComponentManager, IAlgManager>{
public:

  struct AlgorithmItem {
    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::list<AlgorithmItem> ListAlg;
  typedef std::map<std::string, std::string> AlgTypeAliasesMap;

  AlgorithmManager( IInterface* iface );
  virtual ~AlgorithmManager();

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

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

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

  virtual StatusCode reinitialize();
  virtual StatusCode restart();

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

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

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

private:
  ListAlg      m_listalg;     

  mutable std::vector<IAlgorithm*> m_listOfPtrs;

  AlgTypeAliasesMap m_algTypeAliases;

};
#endif  // GAUDISVC_ALGORITHMFACTORY_H