GaudiAlgorithm.h

Go to the documentation of this file.

#ifndef GAUDIALG_GaudiAlgorithm_H
#define GAUDIALG_GaudiAlgorithm_H 1
// ============================================================================
// Include files
// ============================================================================
#include <string>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Algorithm.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/GaudiAlg.h"
#include "GaudiAlg/GaudiCommon.h"
#include "GaudiKernel/DataObjectHandle.h"
// ============================================================================
// forward declarations:
// ============================================================================
class INTupleSvc;

// ============================================================================
// ============================================================================
// ============================================================================
class GAUDI_API GaudiAlgorithm : public GaudiCommon<Algorithm>
{
public:
  // ==========================================================================
  StatusCode initialize() override;
  // ==========================================================================
  StatusCode execute() override;
  // ==========================================================================
  StatusCode finalize() override;
  // ==========================================================================
  StatusCode sysExecute( const EventContext& ctx ) override;
  // ==========================================================================
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 typename Gaudi::Utils::GetData<TYPE>::return_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 typename Gaudi::Utils::GetData<TYPE>::return_type
  getIfExists( IDataProviderSvc* svc, const std::string& location, const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::getIfExists<TYPE>( svc, location, useRootInTES );
  }

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

  template <class TYPE>
  inline typename Gaudi::Utils::GetData<TYPE>::return_type getIfExists( const std::string& location,
                                                                        const bool useRootInTES = true ) const
  {
    return GaudiCommon<Algorithm>::getIfExists<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 typename Gaudi::Utils::GetData<TYPE>::return_type getDetIfExists( IDataProviderSvc* svc,
                                                                           const std::string& location ) const
  {
    return GaudiCommon<Algorithm>::getIfExists<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 typename Gaudi::Utils::GetData<TYPE>::return_type getDetIfExists( const std::string& location ) const
  {
    return GaudiCommon<Algorithm>::getIfExists<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 typename Gaudi::Utils::GetData<TYPE>::return_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 typename Gaudi::Utils::GetData<TYPE>::return_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 );
  // ==========================================================================
  ~GaudiAlgorithm() override = default;
  // ==========================================================================
public:
  // ==========================================================================
  SmartIF<INTupleSvc>& evtColSvc() const;
  // ==========================================================================
  // no default/copy constructor, no assignment -- except that ROOT really
  // wants a default constructor declared. So we define it, and don't implement
  // it...
  GaudiAlgorithm( const GaudiAlgorithm& ) = delete;
  GaudiAlgorithm& operator=( const GaudiAlgorithm& ) = delete;

private:
  GaudiAlgorithm();
  // ==========================================================================
private:
  // ==========================================================================
  // Pointer to the Event Tag Collection Service
  mutable SmartIF<INTupleSvc> m_evtColSvc; 

  Gaudi::Property<std::vector<std::string>> m_vetoObjs{
      this, "VetoObjects", {}, "skip execute if one or more of these TES objects exist"};
  Gaudi::Property<std::vector<std::string>> m_requireObjs{
      this, "RequireObjects", {}, "execute only if one or more of these TES objects exist"};
  // ==========================================================================
};
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_GaudiAlgorithm_H
// ============================================================================