SgTEvent.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ASGTOOLS_SGTEVENT_ICC
#define ASGTOOLS_SGTEVENT_ICC
 
// System include(s):
#include <iostream>
 
#include <CxxUtils/AthUnlikelyMacros.h>
 
// xAOD include(s):
#ifdef XAOD_STANDALONE
#   include "xAODRootAccess/TEvent.h"
#   include "xAODRootAccess/TStore.h"
#endif // XAOD_STANDALONE
 
namespace asg {
 
   /// A constant used in the error message printouts
   static const char* ERROR_SOURCE = "asg::SgTEvent             ERROR   ";
 
   template< typename T >
   bool SgTEvent::contains( const std::string& name ) const {
 
      // Make sure the object is initialised:
      if( ATH_UNLIKELY ( ! m_pevm ) && initialize().isFailure() ) {
         std::cout << ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return false;
      }
 
      // Check if the object is in the transient store:
      if ( m_ptds && m_ptds->template contains< T >( name ) ) {
         return true;
      }
 
      // Check if the object is in the event store:
      return m_pevm->template contains< T >( name );
   }
 
   template< typename T >
   bool SgTEvent::transientContains( const std::string& name ) const {
 
      // Make sure the object is initialised:
      if( ATH_UNLIKELY ( ! m_pevm ) && initialize().isFailure() ) {
         std::cout << ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return false;
      }
 
      // Check if the object is in the transient store:
      if ( m_ptds && m_ptds->template contains< T >( name ) ) {
         return true;
      }
 
      // Check if the object is in the event store:
      return m_pevm->template transientContains< T >( name );
   }
 
   template< typename T >
   T* SgTEvent::retrieve( const std::string& name ) const {
 
      // Make sure the object is initialised:
      if( ATH_UNLIKELY ( ! m_pevm ) && initialize().isFailure() ) {
         std::cout << ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return 0;
      }
 
      // Pointer used in the retrieval:
      T* pobj = 0;
 
      // Check the transient store first:
      if( m_ptds && m_ptds->template contains< T >( name ) ) {
         if( m_ptds->retrieve( pobj, name ).isSuccess() ) {
            return pobj;
         } else {
            return 0;
         }
      }
 
      // If it's not there, then check the event store:
      if( m_pevm->retrieve( pobj, name ).isSuccess() ) {
         return pobj;
      } else {
         return 0;
      }
   }
 
   template< typename T >
   StatusCode SgTEvent::retrieve( T*& pobj, const std::string& name ) {
 
      pobj = retrieve< T >( name );
      if( ATH_LIKELY( pobj ) ) {
         return StatusCode::SUCCESS;
      } else {
         return StatusCode::FAILURE;
      }
   }
 
   template< typename T >
   StatusCode SgTEvent::retrieve( const T*& pobj,
                                  const std::string& name ) const {
 
      pobj = retrieve< const T >( name );
      if( ATH_LIKELY( pobj ) ) {
         return StatusCode::SUCCESS;
      } else {
         return StatusCode::FAILURE;
      }
   }
 
   template< typename T >
   StatusCode SgTEvent::record( std::unique_ptr<T> pobj, const std::string& name ) {
 
      // Make sure the object is initialised:
      if( ATH_UNLIKELY ( ! m_pevm ) && initialize().isFailure() ) {
         std::cout << ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return StatusCode::FAILURE;
      }
 
      // If a transient store is available, try recording it there:
      if( m_ptds ) {
         if( m_ptds->record( std::move( pobj ), name ).isSuccess() ) {
            return StatusCode::SUCCESS;
         } else {
            return StatusCode::FAILURE;
         }
      }
 
      // If not, then let's try with the event store:
      if( m_pevm->record( std::move( pobj ), name ).isSuccess() ) {
         return StatusCode::SUCCESS;
      } else {
         return StatusCode::FAILURE;
      }
   }
 
   template< typename T >
   StatusCode SgTEvent::record( T* pobj, const std::string& name ) {
     // this is the legacy interface, forwarding it to new one
     return record( std::unique_ptr<T>(pobj), name );
   }
 
   /// Container overwriting is not allowed in standalone mode. The function is
   /// just here to allow the compilation of code that was mainly written for
   /// the offline environment. (In case the behaviour of the code is chosen
   /// according to its runtime configuration.)
   ///
   /// As it's a dummy, function parameters are not described here. They are
   /// modeled after the <code>StoreGateSvc::overwrite</code> function.
   ///
   template< typename T >
   StatusCode SgTEvent::overwrite( T* /*obj*/, const std::string& /*name*/,
                                   bool /*allowMods*/, bool /*resetOnly*/,
                                   bool /*noHist*/ ) {
 
      std::cout << ERROR_SOURCE << "Can't use overwrite in standalone mode"
                << std::endl;
      return StatusCode::FAILURE;
   }
 
   template< typename T >
   void SgTEvent::keys( std::vector< std::string >& vkeys ) const {
      if ( m_ptds ) {
         m_ptds->keys< T >(vkeys);
      } else if ( m_pevm ) {
         m_pevm->keys< T >(vkeys);
      }
   }
 
} // namespace asg
 
#endif // ASGTOOLS_SGTEVENT_ICC