TStore.icc

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
//
#ifndef XAODROOTACCESS_TSTORE_ICC
#define XAODROOTACCESS_TSTORE_ICC
 
#include "AthContainers/normalizedTypeinfoName.h"
 
// ROOT include(s):
#include <TError.h>
 
// EDM include(s):
#include "AthContainers/normalizedTypeinfoName.h"
 
// Local include(s):
#include "xAODRootAccess/tools/TDestructorRegistry.h"
#include "xAODRootAccess/tools/TCDVHolderT.h"
 
namespace xAOD {
 
   template< typename T >
   ::Bool_t TStore::contains( const std::string& key ) const {
 
      // Delegate the call:
      return contains( key, typeid( T ) );
   }
 
   template< typename T >
   ::Bool_t TStore::isConst( const std::string& key ) const {
 
      // Delegate the call:
      return isConst( key, typeid( T ) );
   }
 
   template< typename T >
   StatusCode TStore::retrieve( const T*& obj, const std::string& key ) const {
 
      // Try to find the object:
      const void* ptr = getConstObject( key, typeid( T ) );
      if( ! ptr ) {
         const std::string typeName = SG::normalizedTypeinfoName( typeid( T ) );
         ::Warning( "xAOD::TStore::retrieve",
                    "Couldn't (const) retrieve \"%s/%s\"",
                    typeName.c_str(), key.c_str() );
         return StatusCode::RECOVERABLE;
      }
 
      // If we were successful:
      obj = reinterpret_cast< const T* >( ptr );
      return StatusCode::SUCCESS;
   }
 
   template< typename T >
   StatusCode TStore::retrieve( T*& obj, const std::string& key ) const {
 
      // Try to find the object:
      void* ptr = getObject( key, typeid( T ) );
      if( ! ptr ) {
         const std::string typeName = SG::normalizedTypeinfoName( typeid( T ) );
         ::Warning( "xAOD::TStore::retrieve",
                    "Couldn't (non-const) retrieve \"%s/%s\"",
                    typeName.c_str(), key.c_str() );
         return StatusCode::RECOVERABLE;
      }
 
      // If we were successful:
      obj = reinterpret_cast< T* >( ptr );
      return StatusCode::SUCCESS;
   }
 
   template< typename T >
   StatusCode TStore::record_impl( T* obj, const std::string& key,
                                   ::Bool_t isOwner, ::Bool_t isConst ) {
 
      // Check if it's possible to record the object with a dictionary:
      StatusCode result = record( obj, key,
                                  SG::normalizedTypeinfoName( typeid( T ) ),
                                  isOwner, isConst );
 
      // If it's a success or a failure, let's stop here. Only go on for a
      // recoverable error:
      if( ! result.isRecoverable() ) {
         return result;
      }
 
      // Apparently we don't have a dictionary for this type. Let's fall back
      // to a slightly dumber implementation then...
 
      // Make sure that we'll be able to destruct this type later on:
      TDestructorRegistry::instance().add< T >();
 
      // Leave it to the non-template function to record the object:
      return record( obj, key, typeid( T ), isOwner, isConst );
   }
 
   template< typename T >
   StatusCode TStore::record( T* obj, const std::string& key ) {
 
      return record_impl( obj, key, /*isOwner*/kTRUE, /*isConst*/kFALSE );
   }
 
 
   template< typename T >
   StatusCode TStore::record( std::unique_ptr< T > obj,
                               const std::string& key ) {
 
      StatusCode result = record_impl( obj.get(), key,
                                       /*isOwner*/kTRUE, /*isConst*/kFALSE );
 
      // In case of success, give up ownership of the object:
      if( result.isSuccess() ) {
         (void)obj.release();
      }
      return result;
   }
 
   template< typename T >
   StatusCode TStore::record( const T* obj, const std::string& key ) {
 
      // We hold object as non-const pointers, but check on retrieval:
      T* nc_obj ATLAS_THREAD_SAFE = const_cast<T*>(obj);
      return record_impl( nc_obj, key, /*isOwner*/kTRUE, /*isConst*/kTRUE );
   }
 
   template< typename T >
   StatusCode TStore::record( std::unique_ptr< const T > obj,
                              const std::string& key ) {
 
      // We hold object as non-const pointers, but check on retrieval:
      T* nc_obj ATLAS_THREAD_SAFE = const_cast<T*>(obj.get());
      StatusCode result = record_impl( nc_obj, key,
                                       /*isOwner*/kTRUE, /*isConst*/kTRUE );
 
      // In case of success, give up ownership of the object:
      if( result.isSuccess() ) {
         (void)obj.release();
      }
      return result;
   }
 
   template< class T >
   StatusCode TStore::record( ConstDataVector< T >* obj, const std::string& key,
                              const std::type_info& ti,
                              ::Bool_t /*isOwner*/, ::Bool_t /*isConst*/ ) {
 
      // Make sure that we'll be able to destruct this type later on:
      TDestructorRegistry::instance().add< T >();
 
      // We always store non-const pointers but check on retrieval:
      THolder* hldr = new TCDVHolderT< T >( obj, ti );
      return record( hldr, key );
   }
 
   template< typename T >
   void TStore::keys( std::vector< std::string >& vkeys ) const {
      getNames( SG::normalizedTypeinfoName( typeid( T ) ), vkeys );
   }
 
 
} // namespace xAOD
 
#endif // XAODROOTACCESS_TSTORE_ICC