TCDVHolderT.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_TOOLS_TCDVHOLDERT_ICC
#define XAODROOTACCESS_TOOLS_TCDVHOLDERT_ICC
 
// ROOT include(s):
#include <TClass.h>
 
namespace xAOD {
 
   template< class T >
   TCDVHolderT< T >::TCDVHolderT( ConstDataVector< T >* object,
                                  const std::type_info& type,
                                  ::Bool_t owner )
      : THolder( static_cast< const void* >( object ), type, owner ),
        m_cdvObject( object ),
        m_holderHelper( object->asDataVector(),
                        ::TClass::GetClass( typeid( typename Object_t::base_data_vector ) ),
                        kFALSE ) {
 
      // In case there's no dictionary for the underlying DataVector type
      // (which should only happen for some tests), let's give a type ID for the
      // helper object.
      if( ! m_holderHelper.getClass() ) {
         m_holderHelper = THolder( object->asDataVector(),
                                   typeid( typename Object_t::base_data_vector ), kFALSE );
      }
 
      // Set our type to the underlying DataVector type
      m_type = m_holderHelper.getClass();
      m_typeInfo = m_holderHelper.getTypeInfo();
   }
 
   template< class T >
   void TCDVHolderT< T >::set( void* obj ) {
 
      // Set our own pointer:
      m_cdvObject = reinterpret_cast< ConstDataVector< T >* >( obj );
 
      // Update the helper object:
      void* nc_dv ATLAS_THREAD_SAFE = // we hold non-const pointers but check on retrieve
        const_cast< void* >( static_cast< const void* >( m_cdvObject->asDataVector() ) );
 
      m_holderHelper.set( nc_dv );
 
      // Finally, update the base class:
      THolder::set( obj );
 
      return;
   }
 
   template< class T >
   void* TCDVHolderT< T >::getAs( const std::type_info& tid,
                                  ::Bool_t silent ) const {
 
      // Non-const retrieval of ConstDataVector is never allowed:
      if( ! silent ) {
         const std::string heldType =
            SG::normalizedTypeinfoName( typeid( Object_t ) );
         const std::string reqType =
            SG::normalizedTypeinfoName( tid );
         ::Warning( "xAOD::TCDVHolder::getAs",
                    "Trying to retrieve %s object with a non-const %s pointer",
                    heldType.c_str(), reqType.c_str() );
      }
 
      return nullptr;
   }
 
   template< class T >
   const void* TCDVHolderT< T >::getAsConst( const std::type_info& tid,
                                             ::Bool_t silent ) const {
 
      // Check if the helper holder can handle the request:
      const void* result = m_holderHelper.getAsConst( tid, kTRUE );
      if( result ) {
         // If yes, then we're done:
         return result;
      }
 
      // In case there was no dictionary for the base class, check whether the
      // user is just asking for the base type:
      if( tid == typeid( typename Object_t::base_data_vector ) ) {
         return m_cdvObject->asDataVector();
      }
      // or the original type:
      else if( tid == typeid( Object_t ) ) {
         return m_cdvObject;
      }
 
      // Otherwise rely on the base class to do its thing:
      return THolder::getAsConst( tid, silent );
   }
 
} // namespace xAOD
 
#endif // XAODROOTACCESS_TOOLS_TCDVHOLDERT_ICC