GaudiCommon.icpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2020 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.                                             *
\***********************************************************************************/
// ============================================================================
/* @file GaudiCommon.cpp
 *
 *  Implementation file for class : GaudiCommon
 *
 *  @author Chris Jones   Christopher.Rob.Jones@cern.ch
 *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
 *  @author Rob Lambert Rob.Lambert@cern.ch
 *  @date   2009-08-04
 */
// ============================================================================
#include "GaudiAlg/GaudiCommon.h"
 
#include "GaudiAlg/GaudiAlgorithm.h"
#include "GaudiAlg/GaudiTool.h"
#include "GaudiAlg/Print.h"
#include "GaudiKernel/AlgTool.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/SmartRef.h"
#include "GaudiKernel/Stat.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/reverse.h"
#include "GaudiUtils/RegEx.h"
#include <algorithm>
#include <cstdlib>
#include <fmt/format.h>
#include <numeric>
 
// ============================================================================
// constructor initialisation
// ============================================================================
template <class PBASE>
void GaudiCommon<PBASE>::initGaudiCommonConstructor( const IInterface* parent ) {
  // setup context from parent if available
  if ( parent ) {
    if ( const GaudiAlgorithm* gAlg = dynamic_cast<const GaudiAlgorithm*>( parent ) ) {
      m_context = gAlg->context();
    } else if ( const GaudiTool* gTool = dynamic_cast<const GaudiTool*>( parent ) ) {
      m_context = gTool->context();
    }
  }
 
  // Get options values from IOptionsSvc
  // \fixme this part is not needed because this method is called in the constructor,
  // and properties are, anyway, set during the initialize... except for Context
  // which might be set in the contructor by GaudiSequencer.
  const auto&       optsSvc = this->serviceLocator()->getOptsSvc();
  const std::string key     = this->name() + ".Context";
  if ( optsSvc.has( key ) ) { this->setPropertyRepr( "Context", optsSvc.get( key ) ).ignore(); }
}
//=============================================================================
 
//=============================================================================
// Initialise the common functionality
//=============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::initialize() {
 
  // initialize base class
  const StatusCode sc = base_class::initialize();
  if ( sc.isFailure() ) { return Error( "Failed to initialise base class PBASE", sc ); }
 
  // some debug printout
  if ( this->msgLevel( MSG::DEBUG ) ) {
    this->debug() << "Initialize base class GaudiCommon<" << System::typeinfoName( typeid( PBASE ) ) << ">" << endmsg;
    if ( !context().empty() ) this->debug() << "Created with context = '" << context() << "'" << endmsg;
  }
 
  // Set up the CounterSummarySvc May need to be changed
  m_counterSummarySvc = this->svcLoc()->service( "CounterSummarySvc", false );
  if ( this->msgLevel( MSG::DEBUG ) ) {
    if ( !m_counterSummarySvc )
      this->debug() << "could not locate CounterSummarySvc, no counter summary will be made" << endmsg;
    else
      this->debug() << "found CounterSummarySvc OK" << endmsg;
  }
 
  // properties will be printed if asked for or in "MSG::DEBUG" mode
  if ( m_propsPrint.value() ) {
    printProps( MSG::ALWAYS );
  } else if ( this->msgLevel( MSG::DEBUG ) ) {
    printProps( MSG::DEBUG );
  }
 
  return sc;
}
//=============================================================================
 
//=============================================================================
// Finalize the common functionality
//=============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::finalize() {
  StatusCode sc = StatusCode::SUCCESS;
 
  // add all counters to the CounterSummarySvc
  if ( m_counterSummarySvc && this->svcLoc()->existsService( "CounterSummarySvc" ) ) {
    if ( this->msgLevel( MSG::DEBUG ) ) this->debug() << "adding counters to CounterSummarySvc" << endmsg;
 
    Gaudi::Utils::RegEx::matchList counterList{m_counterList.value()};
 
    for ( const auto& i : m_countersOwn ) {
      if ( counterList.Or( i.first ) ) m_counterSummarySvc->addCounter( this->name(), i.first, i.second );
    }
  }
  // release all located tools and services
  if ( this->msgLevel( MSG::DEBUG ) ) {
    this->debug() << "Tools to release :";
    for ( const auto& i : m_managedTools ) { this->debug() << " " << i->name(); }
    this->debug() << endmsg;
  }
  while ( !m_managedTools.empty() ) {
    sc = ( releaseTool( m_managedTools.back() ) && sc ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }
 
  // release all located services
  if ( this->msgLevel( MSG::DEBUG ) ) {
    this->debug() << "Services to release :";
    for ( const auto& i : m_services ) this->debug() << " " << i->name();
    this->debug() << endmsg;
  }
  while ( !m_services.empty() ) {
    sc = ( releaseSvc( m_services.front() ) && sc ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }
 
  // release the CounterSummarySvc manually
  m_counterSummarySvc.reset();
 
  // format printout
  if ( !m_errors.empty() || !m_warnings.empty() || !m_exceptions.empty() ) {
    this->always() << "Exceptions/Errors/Warnings/Infos Statistics : " << m_exceptions.size() << "/" << m_errors.size()
                   << "/" << m_warnings.size() << "/" << m_infos.size() << endmsg;
    if ( m_errorsPrint.value() ) { printErrors(); }
  }
 
  // clear *ALL* counters explicitly
  m_countersOwn.clear(); // then delete any owned counters
  m_exceptions.clear();
  m_infos.clear();
  m_warnings.clear();
  m_errors.clear();
  m_counterList.clear();
 
  // finalize base class
  return ( sc && base_class::finalize() ? StatusCode::SUCCESS : StatusCode::FAILURE );
}
//=============================================================================
 
//=============================================================================
// Methods related to tools and services
//=============================================================================
 
// ============================================================================
// manual forced (and 'safe') release of the active tool or service
// ============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::release( const IInterface* interface ) const {
  if ( !interface ) { return Error( "release(IInterface):: IInterface* points to NULL!" ); }
  // dispatch between tools and services
  const IAlgTool* algTool = dynamic_cast<const IAlgTool*>( interface );
  // perform the actual release
  return algTool ? releaseTool( algTool ) : releaseSvc( interface );
}
// ============================================================================
 
// ============================================================================
// manual forced (and 'save') release of the tool
// ============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::releaseTool( const IAlgTool* algTool ) const {
  if ( !algTool ) { return Error( "releaseTool(IAlgTool):: IAlgTool* points to NULL!" ); }
  if ( !this->toolSvc() ) { return Error( "releaseTool(IAlgTool):: IToolSvc* points to NULL!" ); }
  // find a tool in the list of active tools
  auto it = std::find( m_managedTools.begin(), m_managedTools.end(), algTool );
  if ( m_managedTools.end() == it ) { return Warning( "releaseTool(IAlgTool):: IAlgTool* is not active" ); }
  // get the tool
  IAlgTool* t = *it;
  // cache name
  const std::string name = t->name();
  if ( this->msgLevel( MSG::DEBUG ) ) { this->debug() << "Releasing tool '" << name << "'" << endmsg; }
  // remove the tool from the lists
  base_class::deregisterTool( t );
  m_managedTools.erase( it );
  // release tool
  if ( this->msgLevel( MSG::DEBUG ) ) {
    this->debug() << "The tool '" << t->name() << "' of type '" << System::typeinfoName( typeid( *t ) )
                  << "' is released" << endmsg;
  }
  const StatusCode sc = this->toolSvc()->releaseTool( t );
  return sc.isSuccess() ? sc : Warning( "releaseTool(IAlgTool):: error from IToolSvc releasing " + name, sc );
}
// ============================================================================
 
// ============================================================================
// manual forced (and 'safe') release of the service
// ============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::releaseSvc( const IInterface* Svc ) const {
  if ( !Svc ) return Error( "releaseSvc(IInterface):: IInterface* points to NULL!" );
  SmartIF<IService> svc{const_cast<IInterface*>( Svc )};
  if ( !svc ) return Warning( "releaseSvc(IInterface):: IInterface* is not a service" );
  auto it = std::lower_bound( std::begin( m_services ), std::end( m_services ), svc, GaudiCommon_details::svc_lt );
  if ( it == m_services.end() || !GaudiCommon_details::svc_eq( *it, svc ) ) {
    return Warning( "releaseSvc(IInterface):: IInterface* is not active" );
  }
  if ( this->msgLevel( MSG::DEBUG ) ) { this->debug() << "Releasing service '" << ( *it )->name() << "'" << endmsg; }
  m_services.erase( it );
  return StatusCode::SUCCESS;
}
// ============================================================================
// ============================================================================
 
// ============================================================================
// Add the given service to the list of active services
// ============================================================================
template <class PBASE>
void GaudiCommon<PBASE>::addToServiceList( SmartIF<IService> svc ) const {
  if ( svc ) {
    auto i = std::lower_bound( std::begin( m_services ), std::end( m_services ), svc, GaudiCommon_details::svc_lt );
    if ( i == std::end( m_services ) || !GaudiCommon_details::svc_eq( *i, svc ) ) {
      m_services.insert( i, std::move( svc ) );
    } else {
      this->warning() << "Service " << svc->name() << " already present -- skipping" << endmsg;
    }
  }
}
// ============================================================================
 
//=============================================================================
// Methods related to messaging
//=============================================================================
 
// ============================================================================
// Print the error  message and return status code
// ============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::Error( std::string_view msg, const StatusCode st, const size_t mx ) const {
  // increase local counter of errors
  const size_t num = increment( m_errors, msg );
  // If suppressed, just return
  if ( num > mx ) {
    return st;
  } else if ( UNLIKELY( num == mx ) ) // issue one-time suppression message
  {
    return Print( std::string{"The   ERROR message is suppressed : '"}.append( msg ).append( "'" ), st, MSG::ERROR );
  }
  // return message
  return Print( msg, st, MSG::ERROR );
}
// ============================================================================
 
// ============================================================================
// Print the warning  message and return status code
// ============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::Warning( std::string_view msg, const StatusCode st, const size_t mx ) const {
  // increase local counter of warnings
  const size_t num = increment( m_warnings, msg );
  // If suppressed, just return
  if ( num > mx ) {
    return st;
  } else if ( UNLIKELY( num == mx ) ) // issue one-time suppression message
  {
    return Print( std::string{"The WARNING message is suppressed : '"}.append( msg ).append( "'" ), st, MSG::WARNING );
  }
  // return message
  return Print( msg, st, MSG::WARNING );
}
// ============================================================================
 
// ============================================================================
// Print the info message and return status code
// ============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::Info( std::string_view msg, const StatusCode st, const size_t mx ) const {
  // increase local counter of warnings
  const size_t num = increment( m_infos, msg );
  // If suppressed, just return
  if ( num > mx ) {
    return st;
  } else if ( UNLIKELY( num == mx ) ) // issue one-time suppression message
  {
    return Print( std::string{"The INFO message is suppressed : '"}.append( msg ).append( "'" ), st, MSG::INFO );
  }
  // return message
  return Print( msg, st, MSG::INFO );
}
// ============================================================================
 
// ============================================================================
//  Print the message and return status code
// ============================================================================
template <class PBASE>
StatusCode GaudiCommon<PBASE>::Print( std::string_view msg, const StatusCode st, const MSG::Level lvl ) const {
  // perform printout ?
  if ( !this->msgLevel( lvl ) ) { return st; } // RETURN
 
  // use the predefined stream
  MsgStream& str = this->msgStream( lvl );
  if ( m_typePrint.value() ) { str << System::typeinfoName( typeid( *this ) ) << ":: "; }
 
  // print the message
  str << msg;
 
  // test status code
  if ( st.isSuccess() ) {
  } else if ( StatusCode::FAILURE != st ) {
    str << " StatusCode=" << st.getCode();
  } else {
    str << " StatusCode=FAILURE";
  }
 
  // perform print operation
  str << endmsg;
 
  // return
  return st;
}
// ============================================================================
 
// ============================================================================
// Create and (re)-throw the exception
// ============================================================================
template <class PBASE>
void GaudiCommon<PBASE>::Exception( std::string_view msg, const GaudiException& exc, const StatusCode sc ) const {
  // increase local counter of exceptions
  increment( m_exceptions, msg );
  Print( std::string{"Exception (re)throw: "}.append( msg ), sc, MSG::FATAL ).ignore();
  throw GaudiException( ( this->name() + ":: " ).append( msg ), this->name(), sc, exc );
}
// ============================================================================
 
// ============================================================================
// Create and (re)-throw the exception
// ============================================================================
template <class PBASE>
void GaudiCommon<PBASE>::Exception( std::string_view msg, const std::exception& exc, const StatusCode sc ) const {
  // increase local counter of exceptions
  increment( m_exceptions, msg );
  Print( std::string{"Exception (re)throw: "}.append( msg ), sc, MSG::FATAL ).ignore();
  throw GaudiException( ( this->name() + ":: " ).append( msg ) + "(" + exc.what() + ")", "", sc );
}
// ============================================================================
 
// ============================================================================
// Create and throw the exception
// ============================================================================
template <class PBASE>
void GaudiCommon<PBASE>::Exception( std::string_view msg, const StatusCode sc ) const {
  // increase local counter of exceptions
  increment( m_exceptions, msg );
  Print( std::string{"Exception throw: "}.append( msg ), sc, MSG::FATAL ).ignore();
  throw GaudiException( ( this->name() + ":: " ).append( msg ), "", sc );
}
// ============================================================================
 
// ============================================================================
// perform the actual printout of error counters
// ============================================================================
template <class PBASE>
long GaudiCommon<PBASE>::printErrors( const MSG::Level level ) const {
  auto print = [&]( const Counter& c, const auto& label ) {
    for ( const auto& i : c ) {
      this->msgStream( level ) << fmt::format( " #{:<10s} = {:<8d} Message = '{}'", label, i.second, i.first )
                               << endmsg;
    }
  };
 
  print( m_exceptions, "EXCEPTIONS" );
  print( m_errors, "ERRORS" );
  print( m_warnings, "WARNINGS" );
  print( m_infos, "INFOS" );
 
  // return total number of errors+warnings+exceptions
  return m_exceptions.size() + m_errors.size() + m_warnings.size() + m_infos.size();
}
// ============================================================================
 
// ============================================================================
// ============================================================================
template <class PBASE>
long GaudiCommon<PBASE>::printProps( const MSG::Level level ) const {
 
  // print ALL properties
  MsgStream&  msg        = this->msgStream( level );
  const auto& properties = this->getProperties();
  msg << "List of ALL properties of " << System::typeinfoName( typeid( *this ) ) << "/" << this->name()
      << "  #properties = " << properties.size() << endmsg;
  for ( const auto& property : reverse( properties ) ) { msg << "Property ['Name': Value] = " << *property << endmsg; }
  return properties.size();
}
// ============================================================================
 
// ============================================================================
// Methods for dealing with the TES and TDS
// ============================================================================
 
// ============================================================================
// put results into Gaudi Event Transient Store
// ============================================================================
template <class PBASE>
DataObject* GaudiCommon<PBASE>::put( IDataProviderSvc* svc, std::unique_ptr<DataObject> object,
                                     std::string_view location, const bool useRootInTES ) const {
  // check arguments
  Assert( svc, "put():: Invalid 'service'!" );
  Assert( static_cast<bool>( object ), "put():: Invalid 'Object'!" );
  Assert( !location.empty(), "put():: Invalid 'address' = '' " );
  // final data location
  const auto& fullLocation = this->fullTESLocation( location, useRootInTES );
  // register the object!
  const StatusCode status = '/' == fullLocation[0] ? svc->registerObject( fullLocation, object.get() )
                                                   : svc->registerObject( "/Event/" + fullLocation, object.get() );
  // check the result!
  DataObject& obj = *object;
  if ( status.isFailure() ) {
    Exception( "put():: could not register '" + System::typeinfoName( typeid( obj ) ) + "' at address '" +
                   fullLocation + "'",
               status );
  }
  if ( this->msgLevel( MSG::DEBUG ) ) {
    Print( "The object of type '" + System::typeinfoName( typeid( obj ) ) + "' is registered in TS at address '" +
               fullLocation + "'",
           status, MSG::DEBUG )
        .ignore();
  }
  // if we get here, ownership has been transferred to the IDataProviderSvc
  return object.release();
}
// ============================================================================
 
// ============================================================================
// The END
// ============================================================================