GaudiAlgorithm.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#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 ??
 
  // [[deprecated( "please pass a std::unique_ptr as 2nd argument" )]]
  void put( IDataProviderSvc* svc, DataObject* object, const std::string& address,
            const bool useRootInTES = true ) const {
    put( svc, std::unique_ptr<DataObject>( object ), address, useRootInTES );
  }
  void put( IDataProviderSvc* svc, std::unique_ptr<DataObject> object, const std::string& address,
            const bool useRootInTES = true ) const {
    GaudiCommon<Algorithm>::put( svc, std::move( object ), address, useRootInTES );
  }
 
  const DataObject* put( DataObject* object, const std::string& address, const bool useRootInTES = true ) const {
    return put( std::unique_ptr<DataObject>( object ), address, useRootInTES );
  }
  const DataObject* put( std::unique_ptr<DataObject> object, const std::string& address,
                         const bool useRootInTES = true ) const {
    return GaudiCommon<Algorithm>::put( evtSvc(), std::move( object ), address, useRootInTES );
  }
 
  template <class TYPE>
  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>
  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>
  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>
  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>
  TYPE* getDet( IDataProviderSvc* svc, const std::string& location ) const {
    return GaudiCommon<Algorithm>::get<TYPE>( svc, location, false );
  }
 
  template <class TYPE>
  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>
  TYPE* getDet( const std::string& location ) const {
    return GaudiCommon<Algorithm>::get<TYPE>( detSvc(), location, false );
  }
 
  template <class TYPE>
  typename Gaudi::Utils::GetData<TYPE>::return_type getDetIfExists( const std::string& location ) const {
    return GaudiCommon<Algorithm>::getIfExists<TYPE>( detSvc(), location, false );
  }
 
  template <class TYPE>
  bool exist( IDataProviderSvc* svc, const std::string& location, const bool useRootInTES = true ) const {
    return GaudiCommon<Algorithm>::exist<TYPE>( svc, location, useRootInTES );
  }
 
  template <class TYPE>
  bool exist( const std::string& location, const bool useRootInTES = true ) const {
    return GaudiCommon<Algorithm>::exist<TYPE>( evtSvc(), location, useRootInTES );
  }
 
  template <class TYPE>
  bool existDet( IDataProviderSvc* svc, const std::string& location ) const {
    return GaudiCommon<Algorithm>::exist<TYPE>( svc, location, false );
  }
 
  template <class TYPE>
  bool existDet( const std::string& location ) const {
    return GaudiCommon<Algorithm>::exist<TYPE>( detSvc(), location, false );
  }
 
  template <class TYPE, class TYPE2>
  typename Gaudi::Utils::GetData<TYPE>::return_type getOrCreate( IDataProviderSvc* svc, std::string_view location,
                                                                 const bool useRootInTES = true ) const {
    return GaudiCommon<Algorithm>::getOrCreate<TYPE, TYPE2>( svc, location, useRootInTES );
  }
 
  template <class TYPE, class TYPE2>
  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 );
  }
 
  // ==========================================================================
  GaudiAlgorithm( std::string name, ISvcLocator* pSvcLocator );
  // ==========================================================================
  //
  // 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;
  // ==========================================================================
public:
  // ==========================================================================
  SmartIF<INTupleSvc>& evtColSvc() const;
 
  // ==========================================================================
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