THolder.cxx

Go to the documentation of this file.

// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 
// ROOT include(s):
#include <TClass.h>
#include <TError.h>
 
// Athena include(s):
#include "AthContainers/normalizedTypeinfoName.h"
#include "AthContainers/AuxVectorBase.h"
#include "AthContainers/AuxElement.h"
#include "CxxUtils/checker_macros.h"
 
// Local include(s):
#include "xAODRootAccess/tools/THolder.h"
#include "xAODRootAccess/tools/Message.h"
#include "xAODRootAccess/tools/TDestructorRegistry.h"
#include "THolderCache.h"
 
namespace {

   xAOD::THolder::TypeKind getTypeKind( const TClass* type ) {
 
      static const TClass* const dvClass =
         TClass::GetClass( typeid( SG::AuxVectorBase ) );
      static const TClass* const aeClass =
         TClass::GetClass( typeid( SG::AuxElement ) );
 
      // Don't waste time (and possibly invoke autoparsing) for types
      // that we know can't satisfy the tests below.  An AuxElement
      // should have type kNotSTL, while a DataVector will have
      // type kSTLlist, by virtue of a setting in TDVCollectionProxy.
      if( type && (type->GetCollectionType() == ROOT::kNotSTL || type->GetCollectionType() == ROOT::kSTLlist) ) {
         if( type->InheritsFrom( dvClass ) ) {
            return xAOD::THolder::DATAVECTOR;
         }
         if( type->InheritsFrom( aeClass ) ) {
            return xAOD::THolder::AUXELEMENT;
         }
      }
      return xAOD::THolder::OTHER;
   }

   void* safe_const_cast(const void* object) {
      void* nc ATLAS_THREAD_SAFE = const_cast<void*>(object);
      return nc;
   }
 
} // private namespace
 
namespace xAOD {
 
   THolder::THolder()
      : m_object( 0 ), m_type( 0 ), m_typeInfo( 0 ), m_owner( kFALSE ),
        m_typeKind( OTHER ), m_const( kFALSE ) {
 
   }
 
   THolder::THolder( void* object, ::TClass* type, ::Bool_t owner )
      : m_object( object ), m_type( type ),
        m_typeInfo( m_type ? m_type->GetTypeInfo() : 0 ), m_owner( owner ),
        m_typeKind( getTypeKind( type ) ), m_const( kFALSE ) {
 
      // Complain if the passed dictionary will be unusable later on:
      if( m_type && ( ! m_type->IsLoaded() ) ) {
         ::Warning( "xAOD::THolder::THolder", "Received an emulated dictionary "
                    "for type: %s", m_type->GetName() );
      }
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
   }
 
   THolder::THolder( void* object, const std::type_info& type, ::Bool_t owner )
      : m_object( object ), m_type( 0 ), m_typeInfo( &type ), m_owner( owner ),
        m_typeKind( OTHER ), m_const( kFALSE ) {
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
   }
 
   THolder::THolder( const void* object, ::TClass* type, ::Bool_t owner )
      : THolder( safe_const_cast(object), type, owner ) {
 
      m_const = kTRUE;
   }
 
   THolder::THolder( const void* object, const std::type_info& type, ::Bool_t owner )
      : THolder( safe_const_cast(object), type, owner ) {
 
      m_const = kTRUE;
   }

   THolder::THolder( const THolder& parent )
      : m_object( parent.m_object ), m_type( parent.m_type ),
        m_typeInfo( parent.m_typeInfo ), m_owner( parent.m_owner ),
        m_typeKind( parent.m_typeKind ), m_const( parent.m_const ) {
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
   }

   THolder::THolder( THolder&& parent )
      : m_object( parent.m_object ), m_type( parent.m_type ),
        m_typeInfo( parent.m_typeInfo ), m_owner( parent.m_owner ),
        m_typeKind( parent.m_typeKind ), m_const( parent.m_const ) {
 
      // Tell the parent that it no longer owns the object:
      parent.m_owner = kFALSE;
   }
 
   //coverity[UNCAUGHT_EXCEPT]
   THolder::~THolder() {
 
      // Delete the object using its dictionary:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
   }

   THolder& THolder::operator=( const THolder& rhs ) {
 
      // Check if we need to do anything:
      if( &rhs == this ) return *this;
 
      // Clean up the previously managed object:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Do the copy:
      m_object   = rhs.m_object;
      m_type     = rhs.m_type;
      m_typeInfo = rhs.m_typeInfo;
      m_owner    = rhs.m_owner;
      m_typeKind = rhs.m_typeKind;
      m_const    = rhs.m_const;
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
 
      // Return this same object:
      return *this;
   }

   THolder& THolder::operator=( THolder&& rhs ) {
 
      // Check if we need to do anything:
      if( &rhs == this ) return *this;
 
      // Clean up the previously managed object:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Do the copy:
      m_object   = rhs.m_object;
      m_type     = rhs.m_type;
      m_typeInfo = rhs.m_typeInfo;
      m_owner    = rhs.m_owner;
      m_typeKind = rhs.m_typeKind;
      m_const    = rhs.m_const;
 
      // Instead of doing anything with the shared count here, just make the
      // parent not own the object anymore. The logic is the same as discussed
      // in the move constructor.
      rhs.m_owner = kFALSE;
 
      // Return this same object:
      return *this;
   }
 
   const void* THolder::get() const {
 
      return m_object;
   }
 
   void* THolder::get() {
 
      return m_object;
   }
 
   void** THolder::getPtr() {
 
      return &m_object;
   }
 
   void THolder::set( void* obj ) {
 
      // Check if we need to do anything:
      if( m_object == obj ) return;
 
      // Delete the previous object:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Hold on to the new object from now on:
      m_object = obj;
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
 
      return;
   }
 
   ::Bool_t THolder::isOwner() const {
 
      return m_owner;
   }
 
   void THolder::setOwner( ::Bool_t state ) {
 
      // Check if anything needs to be done:
      if( state == m_owner ) return;
 
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         ::Warning( "xAOD::THolder::setOwner",
                    "Deleting object %p no longer held by any owner",
                    m_object );
         deleteObject();
      }
 
      m_owner = state;
 
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
 
      return;
   }
 
   ::Bool_t THolder::isConst() const {
 
      return m_const;
   }
 
   void THolder::setConst() {
 
      m_const = kTRUE;
   }

   void* THolder::getImpl( const std::type_info& tid,
                           ::Bool_t silent ) const {
 
      // If there is no dictionary for the object, then the logic is pretty
      // simple:
      if( ! m_type ) {
         // Check if the user asked for the right type. Remember that in this
         // case we can't return an object as its base type.
         if( tid != *m_typeInfo ) {
            if( ! silent ) {
               const std::string heldType =
                  SG::normalizedTypeinfoName( *m_typeInfo );
               const std::string reqType =
                  SG::normalizedTypeinfoName( tid );
               ::Warning( "xAOD::THolder::getAs",
                          "Trying to retrieve %s object with a %s pointer",
                          heldType.c_str(), reqType.c_str() );
            }
            return 0;
         }
         // The user did ask for the correct type:
         return m_object;
      }
 
      // Check if we already know about this type:
      auto userClass = Internal::THolderCache::instance().getClass( tid );
      // If not, look for it now:
      if( ! userClass.first ) {
         userClass.second = ::TClass::GetClass( tid );
         Internal::THolderCache::instance().addClass( tid, userClass.second );
      }
 
      // If we still don't have a dictionary, that's an issue:
      if( ! userClass.second ) {
         if( ! silent ) {
            ::Error( "xAOD::THolder::getAs",
                     XAOD_MESSAGE( "Couldn't access the dictionary for user "
                                   "type: %s" ),
                     SG::normalizedTypeinfoName( tid ).c_str() );
         }
         return 0;
      }
 
      // Check if the user requested a valid base class for the held type.
      //
      // Calling GetBaseClassOffset is in general not thread-safe as it could
      // trigger the loading and parsing of StreamerInfo. However, we assume
      // that this has already been done once we get here.
      TClass* cl ATLAS_THREAD_SAFE = m_type;
      const Int_t offset = cl->GetBaseClassOffset( userClass.second );
      if( offset < 0 ) {
         if( ! silent ) {
            ::Warning( "xAOD::THolder::getAs",
                       "User class \"%s\" is not a valid base "
                       "of \"%s\"",
                       SG::normalizedTypeinfoName( tid ).c_str(),
                       m_type->GetName() );
         }
         return 0;
      }
 
      // If all is fine, do the cast:
      return ( static_cast< char* >( m_object ) + offset );
   }

   void* THolder::getAs( const std::type_info& tid,
                         ::Bool_t silent ) const {
 
      if( m_const ) {
         if( ! silent ) {
            ::Warning( "xAOD::THolder::getAs",
                       "Trying to retrieve const \"%s\" via non-const pointer \"%s\"",
                       m_type->GetName(),
                       SG::normalizedTypeinfoName( tid ).c_str() );
         }
         return nullptr;
      }
      return getImpl( tid, silent );
   }

   const void* THolder::getAsConst( const std::type_info& tid,
                                    ::Bool_t silent ) const {
 
      // In the generic case we just forward this call:
      return getImpl( tid, silent );
   }
 
   const ::TClass* THolder::getClass() const {
 
      return m_type;
   }
 
   ::TClass* THolder::getClass() {
 
      return m_type;
   }
 
   const std::type_info* THolder::getTypeInfo() const {
 
      return m_typeInfo;
   }

   void THolder::renew() {
 
      // Delete the object using its dictionary:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Create a new object:
      m_owner = kTRUE;
      m_object = m_type->New();
      Internal::THolderCache::instance().incRef( m_object );
 
      // Return gracefuly:
      return;
   }
 
   void THolder::deleteObject() {
 
      // Check if we even have an object:
      if( ! m_object ) {
         return;
      }
 
      // Delete the object then:
      if( m_type ) {
         if( m_type->IsLoaded() ) {
            m_type->Destructor( m_object );
         }
         // In certain situations it can happen that the memory cleanup for a
         // particular TEvent object happens after ROOT already started to
         // unload libraries from memory. In this case, since the application
         // is anyway on its final leg, let's not bother the user with
         // additional warnings about not being able to clean up after the
         // managed object.
      } else if( m_typeInfo ) {
         const TVirtualDestructor* d =
            TDestructorRegistry::instance().get( *m_typeInfo );
         if( d ) {
            d->destruct( m_object );
         } else {
            ::Error( "xAOD::THolder::deleteObject",
                     XAOD_MESSAGE( "Couldn't delete managed object" ) );
         }
      } else {
         ::Error( "xAOD::THolder::deleteObject",
                  XAOD_MESSAGE( "Couldn't delete managed object" ) );
      }
 
      return;
   }
 
} // namespace xAOD