GaudiTool.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_GAUDITOOL_H
#define GAUDIALG_GAUDITOOL_H 1
// ============================================================================
// Include files
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/AlgTool.h"
#include "GaudiKernel/CounterHolder.h"
#include "GaudiKernel/DataObject.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/GaudiAlg.h"
#include "GaudiAlg/GaudiCommon.h"
#include "GaudiKernel/DataObjectHandle.h"
// ============================================================================
// forward declarations
// ============================================================================
class IDataProviderSvc;
class IChronoStatSvc;
class IIncidentSvc;
class IHistogramSvc;
class GaudiException;
class INTupleSvc;
class IAlgContextSvc;
namespace std {
  class exception;
}
// ============================================================================
// ============================================================================
// ============================================================================
class GAUDI_API GaudiTool : public GaudiCommon<CounterHolder<AlgTool>> {
public:
  // ==========================================================================
  StatusCode initialize() override;
  StatusCode finalize() override;
  // ==========================================================================
public: // accessors
        // ==========================================================================
  INTupleSvc* ntupleSvc() const;
  INTupleSvc* evtColSvc() const;
  IDataProviderSvc* detSvc() const;

  IIncidentSvc* incSvc() const;
  IChronoStatSvc* chronoSvc() const;
  IHistogramSvc* histoSvc() const;
  IAlgContextSvc* contextSvc() const;
  // ==========================================================================
public:
  // ==========================================================================
  // following methods cannot go in GaudiCommon since they use methods ( evtSvc()
  // and detSvc() ) 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<CounterHolder<AlgTool>>::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<CounterHolder<AlgTool>>::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<CounterHolder<AlgTool>>::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<CounterHolder<AlgTool>>::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<CounterHolder<AlgTool>>::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<CounterHolder<AlgTool>>::getIfExists<TYPE>( evtSvc(), location, useRootInTES );
  }

  template <class TYPE>
  TYPE* getDet( IDataProviderSvc* svc, const std::string& location ) const {
    return GaudiCommon<CounterHolder<AlgTool>>::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<CounterHolder<AlgTool>>::getIfExists<TYPE>( svc, location, false );
  }

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

  template <class TYPE>
  typename Gaudi::Utils::GetData<TYPE>::return_type getDetIfExists( const std::string& location ) const {
    return GaudiCommon<CounterHolder<AlgTool>>::getIfExists<TYPE>( detSvc(), location, false );
  }

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

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

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

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

  template <class TYPE, class TYPE2>
  typename Gaudi::Utils::GetData<TYPE>::return_type getOrCreate( IDataProviderSvc* svc, const std::string& location,
                                                                 const bool useRootInTES = true ) const {
    return GaudiCommon<CounterHolder<AlgTool>>::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<CounterHolder<AlgTool>>::getOrCreate<TYPE, TYPE2>( evtSvc(), location, useRootInTES );
  }
  // ==========================================================================
public:
  // ==========================================================================
  StatusCode Error( const std::string& msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const {
    return GaudiCommon<CounterHolder<AlgTool>>::Error( m_isPublic ? msg + getCurrentAlgName() : msg, st, mx );
  }
  StatusCode Warning( const std::string& msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const {
    return GaudiCommon<CounterHolder<AlgTool>>::Warning( m_isPublic ? msg + getCurrentAlgName() : msg, st, mx );
  }
  StatusCode Info( const std::string& msg, const StatusCode st = StatusCode::SUCCESS, const size_t mx = 10 ) const {
    return GaudiCommon<CounterHolder<AlgTool>>::Info( m_isPublic ? msg + getCurrentAlgName() : msg, st, mx );
  }
  // ==========================================================================
public:
  // ==========================================================================
  static bool enableSummary( bool );
  static bool summaryEnabled();

  // ==========================================================================
  GaudiTool( std::string type, std::string name, const IInterface* parent );

  ~GaudiTool() override;
  // ==========================================================================
private:
  // ==========================================================================
  GaudiTool( const GaudiTool& ) = delete;
  GaudiTool& operator=( const GaudiTool& ) = delete;
  // ==========================================================================
private:
  // ==========================================================================
  bool isPublic() const;
  std::string getCurrentAlgName() const {
    const IAlgContextSvc* asvc    = this->contextSvc();
    const IAlgorithm*     current = ( asvc ? asvc->currentAlg() : NULL );
    return ( current ? " [" + current->name() + "]" : "" );
  }
  // ==========================================================================
private:
  // ==========================================================================
  mutable SmartIF<INTupleSvc> m_ntupleSvc;
  mutable SmartIF<INTupleSvc> m_evtColSvc;
  mutable SmartIF<IDataProviderSvc> m_detSvc;
  mutable SmartIF<IChronoStatSvc> m_chronoSvc;
  mutable SmartIF<IIncidentSvc> m_incSvc;
  mutable SmartIF<IHistogramSvc> m_histoSvc;
  // Pointer to the Algorithm Context Service
  mutable SmartIF<IAlgContextSvc> m_contextSvc; 

  Gaudi::Property<std::string> m_contextSvcName{this, "ContextService", "AlgContextSvc",
                                                "the name of Algorithm Context Service"};
  // ==========================================================================
private:
  // ==========================================================================
  bool m_isPublic = false;
  // ==========================================================================
private:
  // ==========================================================================
  const std::string m_local;
  // ==========================================================================
private:
  // ==========================================================================
  static bool s_enableSummary;
  // ==========================================================================
};
// ============================================================================

// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_GAUDITOOL_H