SgTEventMeta.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ASGTOOLS_SGTEVENTMETA_ICC
#define ASGTOOLS_SGTEVENTMETA_ICC
 
// System include(s):
#include <iostream>
 
// xAOD include(s):
#ifdef XAOD_STANDALONE
#   include "xAODRootAccess/TEvent.h"
#endif // XAOD_STANDALONE
 
namespace asg {
 
   /// A constant used in the error message printouts
   static const char* META_ERROR_SOURCE = "asg::SgTEventMeta         ERROR   ";
 
   template< typename T >
   bool SgTEventMeta::contains( const std::string& name ) {
 
      // Make sure the object is initialised:
      if( ( ! m_event ) && initialize().isFailure() ) {
         std::cout << META_ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return false;
      }
 
      // Decide which function to call:
      if( m_type == InputStore ) {
         return m_event->template containsMeta< T >( name );
      } else if( m_type == OutputStore ) {
         return m_event->template transientContainsMeta< T >( name );
      } else {
         std::cout << META_ERROR_SOURCE << "Unknown store type (" << m_type
                   << ") defined" << std::endl;
         return false;
      }
   }
 
   template< typename T >
   bool SgTEventMeta::transientContains( const std::string& name ) const {
 
      // Make sure the object is initialised:
      if( ( ! m_event ) && initialize().isFailure() ) {
         std::cout << META_ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return false;
      }
 
      // Forward the call:
      return m_event->template transientContainsMeta< T >( name );
   }
 
   template< typename T >
   StatusCode SgTEventMeta::retrieve( T*& obj, const std::string& name ) {
 
      // Make sure the object is initialised:
      if( ( ! m_event ) && initialize().isFailure() ) {
         std::cout << META_ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return StatusCode::FAILURE;
      }
 
      // We can only non-const retrieve from the output store:
      if( m_type == InputStore ) {
         std::cout << META_ERROR_SOURCE << "It's not possible to non-const "
                   << "retrieve objects from the input metadata store"
                   << std::endl;
         return StatusCode::FAILURE;
      }
 
      // Forward the call:
      if( ! m_event->retrieveMetaOutput( obj, name ).isSuccess() ) {
         std::cout << META_ERROR_SOURCE << "Failed to retrieve output metadata "
                   << "object with name " << name << std::endl;
         return StatusCode::FAILURE;
      }
 
      // We succeeded:
      return StatusCode::SUCCESS;
   }
 
   template< typename T >
   StatusCode SgTEventMeta::retrieve( const T*& obj, const std::string& name ) {
 
      // Make sure the object is initialised:
      if( ( ! m_event ) && initialize().isFailure() ) {
         std::cout << META_ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return StatusCode::FAILURE;
      }
 
      // Decide which function to call:
      if( m_type == InputStore ) {
         // Forward the call:
         if( ! m_event->retrieveMetaInput( obj, name ).isSuccess() ) {
            std::cout << META_ERROR_SOURCE << "Failed to retrieve input "
                      << "metadata object with name " << name << std::endl;
            return StatusCode::FAILURE;
         }
      } else if( m_type == OutputStore ) {
         // Forward the call:
         if( ! m_event->retrieveMetaOutput( obj, name ).isSuccess() ) {
            std::cout << META_ERROR_SOURCE << "Failed to retrieve output "
                      << "metadata object with name " << name << std::endl;
            return StatusCode::FAILURE;
         }
      } else {
         std::cout << META_ERROR_SOURCE << "Unknown store type (" << m_type
                   << ") defined" << std::endl;
         return StatusCode::FAILURE;
      }
 
      // We succeeded:
      return StatusCode::SUCCESS;
   }
 
   template< typename T >
   StatusCode SgTEventMeta::record( std::unique_ptr<T> obj, const std::string& name ) {
 
      // Make sure the object is initialised:
      if( ( ! m_event ) && initialize().isFailure() ) {
         std::cout << META_ERROR_SOURCE << "Couldn't initialise the tool"
                   << std::endl;
         return StatusCode::FAILURE;
      }
 
      // We can't record stuff into the input store:
      if( m_type == InputStore ) {
         std::cout << META_ERROR_SOURCE << "It's not possible to record "
                   << "objects into the input metadata store" << std::endl;
         return StatusCode::FAILURE;
      }
 
      // Forward the call:
      if( ! m_event->recordMeta( std::move( obj ), name ).isSuccess() ) {
         std::cout << META_ERROR_SOURCE << "Failed to record output metadata "
                   << "object with name " << name << std::endl;
         return StatusCode::FAILURE;
      }
 
      // We succeeded:
      return StatusCode::SUCCESS;
   }
 
   template< typename T >
   StatusCode SgTEventMeta::record( T* obj, const std::string& name ) {
     // this is the legacy interface, forwarding it to new one
     return record( std::unique_ptr<T>(obj), name );
   }
 
   template< typename T >
   void SgTEventMeta::keys( std::vector< std::string >& vkeys ) const {
      if (m_event)
         m_event->keys<T>(vkeys, true); // true tells TEvent to scan metadata
   }
 
} // namespace asg
 
#endif // ASGTOOLS_SGTEVENTMETA_ICC