Gaudi Framework, version v20r2
	Generated: 18 Jul 2008

GaudiAlgorithm.h

Go to the documentation of this file.

// $Id: GaudiAlgorithm.h,v 1.17 2007/09/25 16:12:41 marcocle Exp $
// ============================================================================
#ifndef GAUDIALG_GaudiAlgorithm_H
#define GAUDIALG_GaudiAlgorithm_H 1
// ============================================================================
// Include files
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Algorithm.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/GaudiAlg.h"
#include "GaudiAlg/GaudiCommon.h"
// ============================================================================
// forward declarations:
// ============================================================================
class                   INTupleSvc     ; // GaudiKernel
class                   IAlgContextSvc ; // GaudiKernel
template<class T> class  AlgFactory    ; // GaudiKernel
// ============================================================================
/* @file GaudiAlgorithm.h
 *
 * Header file for class GaudiAlgorithm.
 * The actual code is mainly imported from
 *   - LHCb Calorimeter software and
 *   - LHCb C++ toolkit for smart and friendly physics analysis "LoKi"
 *
 *  This base class allows "easy"(=="1 line") access to tools
 *  and services. This access is safe in the sense that there
 *  is no need to worry about the reference counts for tools
 *  and services.
 *
 *  The base class allows "easy" (=="1 line") access to data in
 *  Gaudi Transient Stores. The functionality includes the checking
 *  of the presence of the data at the given location, checking the
 *  validity of the data, retrieval of valid data and "forced" retrive
 *  of valid data (create if there is no data).
 *
 *  The base class allows to perform an easy error, warning and exception
 *  treatments, including the accumulated statistics of exceptions, errors
 *  and warnings.
 *
 *  The base class also includes utilities for general statistical counters.
 *
 *  It has been reported that usage of this base class results in
 *  significant shrinkage of existing code lines.
 *
 *  @attention
 *  See also the class GaudiCommon, which implements some of the common
 *  functionality between GaudiTool and GaudiAlgorithm.
 *
 *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
 *  @author Chris Jones   Christopher.Rob.Jones@cern.ch
 *  @date 30/06/2001
 */
// ============================================================================
// ============================================================================
class GaudiAlgorithm : public GaudiCommon<Algorithm>
{
  // friend factory for instantiation
  friend class AlgFactory<GaudiAlgorithm>;
public:
  // ==========================================================================
  virtual StatusCode initialize();
  // ==========================================================================
  virtual StatusCode execute   ();
  // ==========================================================================
  virtual StatusCode finalize  ();
  // ==========================================================================
  virtual StatusCode sysExecute () ;
  // ==========================================================================  
public:

  // following methods cannot go in GaudiCommon since they use methods ( evtSvc()
  // and detDvc() ) that are not members of AlgTool.
  // Also some methods seem which are members of the base class do not seem
  // to be found unless forwarding methods are put here ??

  inline void put ( IDataProviderSvc*  svc     ,
                    DataObject*        object  ,
                    const std::string& address ,
                    const bool useRootInTES = true ) const
  {
    GaudiCommon<Algorithm>::put ( svc , object , address , useRootInTES ) ;
  }

  inline void put ( DataObject*        object   ,
                    const std::string& address  ,
                    const bool useRootInTES = true ) const
  {
    GaudiCommon<Algorithm>::put ( evtSvc() , object , address , useRootInTES ) ;
  }

  template < class TYPE  >
  inline TYPE* get  ( IDataProviderSvc*  svc       ,
                      const std::string& location  ,
                      const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::get<TYPE> ( svc , location , useRootInTES ) ;
  }

  template < class TYPE  >
  inline TYPE* get  ( const std::string& location,
                      const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::get<TYPE> ( evtSvc() , location , useRootInTES ) ;
  }

  template < class TYPE  >
  inline TYPE* getDet ( IDataProviderSvc*  svc        ,
                        const std::string& location   ) const
  {
    return GaudiCommon<Algorithm>::get<TYPE> ( svc , location , false ) ;
  }

  template < class TYPE  >
  inline TYPE* getDet ( const std::string& location   ) const
  {
    return GaudiCommon<Algorithm>::get<TYPE> ( detSvc() , location , false ) ;
  }

  template < class TYPE  >
  inline bool  exist    ( IDataProviderSvc*  svc      ,
                          const std::string& location ,
                          const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::exist<TYPE> ( svc , location , useRootInTES ) ;
  }

  template < class TYPE  >
  inline bool  exist    ( const std::string& location ,
                          const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::exist<TYPE> ( evtSvc() , location , useRootInTES ) ;
  }

  template < class TYPE  >
  inline bool  existDet    ( IDataProviderSvc*  svc      ,
                             const std::string& location ) const
  {
    return GaudiCommon<Algorithm>::exist<TYPE> ( svc , location , false ) ;
  }

  template < class TYPE  >
  inline bool  existDet    ( const std::string& location ) const
  {
    return GaudiCommon<Algorithm>::exist<TYPE> ( detSvc() , location , false ) ;
  }

  template < class TYPE , class TYPE2 >
  inline TYPE* getOrCreate ( IDataProviderSvc*  svc      ,
                             const std::string& location ,
                             const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::getOrCreate<TYPE,TYPE2> ( svc , location , useRootInTES ) ;
  }

  template < class TYPE , class TYPE2 >
  inline TYPE* getOrCreate ( const std::string& location ,
                             const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::getOrCreate<TYPE,TYPE2> ( evtSvc() , location , useRootInTES ) ;
  }
public:
  // ==========================================================================
  GaudiAlgorithm ( const std::string& name        ,
                   ISvcLocator*       pSvcLocator );
  // ==========================================================================
  virtual ~GaudiAlgorithm();
  // ==========================================================================
public:
  // ==========================================================================
  inline bool registerContext() const { return m_registerContext ; }
  // ==========================================================================  
public:
  // ==========================================================================
  INTupleSvc*     evtColSvc  () const;
  // ==========================================================================
  IAlgContextSvc* contextSvc () const;
  // ==========================================================================
private:
  // ==========================================================================
  // no public default constructor
  GaudiAlgorithm(); 
  // ==========================================================================
  // no public copy constructor
  GaudiAlgorithm             ( const GaudiAlgorithm& ); 
  // ==========================================================================
  // no public assignment operator
  GaudiAlgorithm& operator = ( const GaudiAlgorithm& ); 
  // ==========================================================================
private:
  // ==========================================================================
  // Pointer to the Event Tag Collection Service
  mutable INTupleSvc*     m_evtColSvc      ; 
  // Pointer to the Algorithm Context Service 
  mutable IAlgContextSvc* m_contextSvc     ; 
  // The name of the Algorithm Context Service 
  std::string             m_contextSvcName ; 
  // enforce the algorithm registration for Algorithm Context Service
  bool    m_registerContext ; 
  // ==========================================================================
};
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_GaudiAlgorithm_H
// ============================================================================

---