IAlgManager.h

Go to the documentation of this file.

// $Id: IAlgManager.h,v 1.7 2008/06/02 14:20:38 marcocle Exp $
#ifndef GAUDIKERNEL_IALGMANAGER_H
#define GAUDIKERNEL_IALGMANAGER_H

// Include files
#include "GaudiKernel/IComponentManager.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/TypeNameString.h"
#include <string>
#include <list>

// Forward class declaration
class IService;
class IAlgorithm;
class ISvcLocator;

class GAUDI_API IAlgManager: virtual public IComponentManager {
public:
  DeclareInterfaceID(IAlgManager, 6, 0);

  virtual StatusCode addAlgorithm( IAlgorithm* alg     // Pointer to the Algorithm
                                 ) = 0;
  virtual StatusCode removeAlgorithm( IAlgorithm* alg  // Pointer to the Algorithm
                                 ) = 0;
  virtual StatusCode createAlgorithm( const std::string& algtype,  // Algorithm type name
                                      const std::string& algname,  // Algorithm name to be assigned
                                      IAlgorithm*& alg,            // Returned algorithm
                                      bool managed = false         // Flag to indicate if the algorithm is managed
                                    ) = 0;
#if !defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR)
  virtual StatusCode getAlgorithm( const std::string& name,        // Algorithm name to be searched
                                   IAlgorithm*& alg                // Returned algorithm
                                 ) const {
    SmartIF<IAlgorithm> &si = const_cast<IAlgManager*>(this)->algorithm(name, false);
    alg = si.get();
    return si.isValid() ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }
#endif
  virtual bool existsAlgorithm( const std::string& name            // Algorithm name to be searched
                              ) const = 0;
  virtual const std::vector<IAlgorithm*>& getAlgorithms() const = 0;

#if !defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR)
  virtual StatusCode initializeAlgorithms() { return initialize(); }

  virtual StatusCode startAlgorithms() { return start(); }

  virtual StatusCode stopAlgorithms() { return stop(); }

  virtual StatusCode finalizeAlgorithms() { return finalize(); }

  virtual StatusCode reinitializeAlgorithms() { return reinitialize(); }

  virtual StatusCode restartAlgorithms() { return restart(); }
#endif

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

  template <typename T>
  inline SmartIF<T> algorithm(const Gaudi::Utils::TypeNameString &typeName, const bool createIf = true) {
    return SmartIF<T>(algorithm(typeName, createIf));
  }

};


#endif  // GAUDI_IALGMANAGER_H