IAlgManager.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_IALGMANAGER_H
#define GAUDIKERNEL_IALGMANAGER_H

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

// 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
                                      bool checkIfExists = true // Flag to indicate if clones of existing algorithms can
                                                                // be created
                                      ) = 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 ? 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;

  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