TDVCollectionProxy.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// System include(s):
#include <cassert>
 
// ROOT include(s):
#include <TError.h>
#include <TClassEdit.h>
#include <TClass.h>
#include <TBaseClass.h>
#include <TCollectionProxyInfo.h>
#include <TSystem.h>
#include <TList.h>
 
// EDM include(s):
#include "AthContainers/DataVector.h"
#include "CxxUtils/no_sanitize_undefined.h"
#include "CxxUtils/checker_macros.h"
#include "RootUtils/Type.h"
 
// Local include(s):
#include "xAODCore/tools/TDVCollectionProxy.h"
 
#include <iostream>
using namespace std;
const bool mn = getenv("MN_DEBUG");
 
namespace xAOD {

   int safeGetBaseOffset( TClass* cls, TClass* base ) {
 
      return cls->GetBaseClassOffset( base );
   }

   TClass* classFromDVClass( TClass* dvclass ) {
 
      // Split up the class name into template arguments.
      std::vector< std::string > args;
      int tailloc;
      {
        // Protect against data race inside TClassEdit.
        // https://github.com/root-project/root/issues/10353
        // Should be fixed in root 6.26.02.
        R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
        TClassEdit::GetSplit( dvclass->GetName(), args, tailloc );
      }
      assert( args.size() > 1 );
 
      // This should be the element type name.
      std::string elname = args[ 1 ];
      assert( elname.size() > 0 );
 
      // Look up the element class.
      TClass* elclass = TClass::GetClass( elname.c_str() );
      if (!elclass) {
         ::Error( "xAOD::TDVCollectionProxy", "Cannot find class %s",
                  elname.c_str() );
      }
 
      return elclass;
   }

   TClass* findDVBase( TClass* dvclass ) {
 
      TIter next( dvclass->GetListOfBases() );
      while( TBaseClass* bcl = dynamic_cast< TBaseClass* >( next() ) ) {
         TClass* cc = bcl->GetClassPointer();
         if( strncmp( cc->GetName(), "DataVector", 10 ) == 0 ) {
            TClass* bdv = findDVBase( cc );
            if( bdv ) return bdv;
            if( strncmp( cc->GetName(), "DataVector<", 11 ) == 0 )
               return cc;
         }
      }
 
      return nullptr;
   }

   std::string findDVElement( TClass* cl ) {
 
      // Make sure that the minimal set of dictionaries are loaded:
      TClass* dummyCl =
         TClass::GetClass( "DataVector<xAOD::TDVCollectionProxyDummy>" );
      if( ! dummyCl ) {
         Error( "xAOD::findDVElement",
                "Couldn't load the dictionary for "
                "DataVector<xAOD::TDVCollectionProxyDummy>" );
         return "";
      }
 
      // Is this a DV class?
      std::string elt;
      const char* name = cl->GetName();
      if( strncmp( name, "DataVector<", 11 ) == 0 ) {
 
         elt = std::string( name + 11, strlen( name ) - 11 - 1 );
 
         // Usually the full DataVector name includes two template
         // arguments. But we only need the first one, before the first comma.
         const std::string::size_type comma = elt.find( ',' );
         if( comma != std::string::npos ) {
            elt.resize (comma);
         }
 
         return elt;
      }
 
      // Scan base classes too.
      TIter next( cl->GetListOfBases() );
      while( TBaseClass* bcl = dynamic_cast< TBaseClass* >( next() ) ) {
         TClass* cc = bcl->GetClassPointer();
         elt = findDVElement( cc );
         if( ! elt.empty() ) {
            break;
         }
      }
 
      return elt;
   }

   class TDVCollectionFuncs {
 
   public:
      typedef std::vector< char* > Cont_t;

      struct TEnvBuff {

         size_t fIndex;

         Cont_t* fCont;

         void* fEltPtr;

         int fOffset;
 
      }; // struct TEnvBuff

      using Env_t = ROOT::TCollectionProxyInfo::Environ<TEnvBuff>;

      static Cont_t* cont( void* env ) {
 
         Env_t& e = *reinterpret_cast< Env_t* >( env );
         TEnvBuff& buff = e.fIterator;
         return buff.fCont;
      }

      static void* first( void* env ) {
         Env_t&  e = *reinterpret_cast< Env_t* >( env );
         Cont_t& c = *cont( env );
         TEnvBuff& buff = e.fIterator;
         buff.fIndex = 0;
         e.fSize  = c.size();
         if( 0 == e.fSize ) {
            return nullptr;
         }
         char* start = c[ 0 ];
         buff.fEltPtr = start + buff.fOffset;
         return buff.fEltPtr;
      }

      static void* next( void* env ) {
 
         Env_t&  e = *reinterpret_cast< Env_t* >( env );
         Cont_t& c = *cont( env );
         TEnvBuff& buff = e.fIterator;
         buff.fIndex += e.fIdx;
         e.fIdx = 0;
         if( buff.fIndex >= e.fSize ) {
            return nullptr;
         }
         char* ptr = c[ buff.fIndex ];
         buff.fEltPtr = ptr + buff.fOffset;
         return buff.fEltPtr;
      }

      static void* size( void* env )  {
 
         Env_t* e = reinterpret_cast< Env_t* >( env );
         e->fSize = cont( env )->size();
         return &( e->fSize );
      }

      static void* clear( void* env ) {
 
         cont( env )->clear();
         return nullptr;
      }

      static void* create_env() {
 
         return new Env_t;
      }
 
      //*************************************************************************
      // These methods are not needed for the xAOD usage,
      // and are not implemented.

      // template <typname T> // T will be equal to final class 
      static void resize( void* /*obj*/, size_t /*size*/ )  {
         ::Fatal( "xAOD::TDVCollectionProxy", "resize function not specified!" );
      }

      static void* construct( void* /*from*/, size_t /*size*/ )  {
         ::Fatal( "xAOD::TDVCollectionProxy", "construct not implemented" );
         return nullptr;
      }

      static void destruct( void* /*obj*/, size_t /*size*/ )  {
         ::Fatal( "xAOD::TDVCollectionProxy", "destruct not implemented" );
      }

      static void* feed( void* /*from*/, void* to, size_t size )
      {
         DataVector<char> *dv = reinterpret_cast<DataVector<char>*>(to);
         // find out vector element typeinfo and get RootUtils::Type for it
         const std::type_info &elem_typeinfo = dv->dvlinfo_v().elt_tinfo();
         auto ru_type = RootUtils::Type( SG::normalizedTypeinfoName(elem_typeinfo) );
         // copy vector elements into DataVector
         if(mn) cout << "PROX:  feed, typename=" << ru_type.getTypeName() << "  typesize=" << ru_type.getSize() <<endl;
 
         //char *src = reinterpret_cast<char*>( from );
         for(size_t i=0; i<size; i++) {
            void *obj = ru_type.create();
            // ru_type.assign(obj, src); //MN: this may crash, so for now we do not copy data (bad only for CaloCluster
            dv->dvlinfo_v().push(dv,obj);
            //src += ru_type.getSize();
         } 
         return nullptr;
      }

      static void* collect( void* /*from*/, void* /*to*/ )  {
         ::Fatal( "xAOD::TDVCollectionProxy", "collect not implemented" );
         return nullptr;
      }
   }; // class TDVCollectionFuncs

   TDVCollectionProxy::TDVCollectionProxy( const char* conttype )
      : TGenCollectionProxy( typeid( DataVector< TDVCollectionProxyDummy > ),
                             sizeof( char* ) ),
        fName( conttype ), fInitialized( kFALSE ),
        fContoff( 0 ), fOffset( 0 ), fEltBase( nullptr ), fEltType( nullptr ) {
 
      // Set up the element size.  No offset, since this isn't a map.
      fValDiff        = sizeof( void* );
      fValOffset      = 0;
 
      // Set up the worker functions.
      fSize.call      = TDVCollectionFuncs::size;
      fNext.call      = TDVCollectionFuncs::next;
      fFirst.call     = TDVCollectionFuncs::first;
      fClear.call     = TDVCollectionFuncs::clear;
      fCollect        = TDVCollectionFuncs::collect;
      fCreateEnv.call = TDVCollectionFuncs::create_env;
      fResize         = TDVCollectionFuncs::resize;
      fConstruct      = TDVCollectionFuncs::construct;
      fDestruct       = TDVCollectionFuncs::destruct;
      fFeed           = TDVCollectionFuncs::feed;
 
      // Make sure that TGenCollectionProxy knows that it's not
      // fully set up yet:
      if( fValue ) {
         delete fValue.exchange( nullptr );
      }
      if( fVal ) {
         delete fVal;
         fVal = nullptr;
      }
 
      // This container pretends to hold objects, not pointers:
      fPointers = kFALSE;
 
      // Remember that we are not initialized yet:
      fProperties = 0;
   }

   TDVCollectionProxy::TDVCollectionProxy( const TDVCollectionProxy& rhs )
      : TGenCollectionProxy( rhs ),
        fName( rhs.fName ),
        fInitialized( rhs.fInitialized ),
        fContoff( rhs.fContoff ),
        fOffset( rhs.fOffset ),
        fEltBase( rhs.fEltBase ),
        fEltType( rhs.fEltType ) {
 
      // If we're not initialised yet, make sure that the base class is
      // on the same page...
      if( ! fInitialized ) {
         if( fValue ) {
            delete fValue.exchange( nullptr );
         }
         if( fVal ) {
            delete fVal;
            fVal = nullptr;
         }
      }
   }

   void TDVCollectionProxy::PushProxy NO_SANITIZE_UNDEFINED ( void* objstart ) {
 
      // Do the base class stuff.
      // This will create an environment buffer if needed.
      ::TGenCollectionProxy::PushProxy( objstart );
 
      // Save the calculated element offset in the environment buffer.
      TDVCollectionFuncs::TEnvBuff& buff =
         reinterpret_cast< TDVCollectionFuncs::Env_t* >( fEnv )->fIterator;
 
      // Get the offset needed for the pointer operations:
      buff.fOffset = fOffset;
 
      // Save the address of the underlying vector of the DataVector.
      // First, adjust the address to the base DataVector.
      char* dvstart = reinterpret_cast< char* >( objstart ) + fContoff;
      // Cast to DV.
      // This gets a ubsan warning about casting between types.
      // However, this is deliberate, so suppress ubsan warnings
      // for this function.
      DataVector< char >* dv =
         reinterpret_cast< DataVector< char >* >( dvstart );
      // Find the underlying vector.
      const std::vector< char* >& vec = dv->stdcont();
      // And store its address.
      std::vector<char*>* vptr ATLAS_THREAD_SAFE =
        const_cast< std::vector< char* >* >( &vec );
      buff.fCont = vptr;
 
      return;
   }

   TVirtualCollectionProxy* TDVCollectionProxy::Generate() const {
 
      return new TDVCollectionProxy( *this );
   }

   void TDVCollectionProxy::SetResize( Sizing_t func ) {
 
      fResize = func;
      return;
   }
 
   TGenCollectionProxy* TDVCollectionProxy::InitializeEx( Bool_t silent ) {
 
      // Check if we're initialised already:
      if( fInitialized ) return this;
 
      // Check for the class's dictionary, and for its element type:
      TClass* cl = TClass::GetClass( fName );
      if( ! cl ) {
         ::Fatal( "xAOD::TDVCollectionProxy::InitializeEx",
                  "Couldn't find dictionary for class %s",
                  fName.Data() );
         return nullptr;
      }
 
      // Check if it is a DataVector:
      const std::string eltname = findDVElement( cl );
      if( eltname.empty() ) {
         ::Fatal( "xAOD::TDVCollectionProxy::InitializeEx",
                  "Class \"%s\" doesn't seem to be a DataVector",
                  cl->GetName() );
         return nullptr;
      }
 
      // Find the container and element offsets.
      FindOffsets( eltname.c_str(), fName );
 
      // Set up the element size.  No offset, since this isn't a map.
      fValDiff        = sizeof( void* );
      fValOffset      = 0;
 
      // Do the base class initialization.
      CheckFunctions();
      TGenCollectionProxy::InitializeEx( silent );
      // xAODRootAccess/THolder relies on the setting below
      // to be able to skip some inheritance tests.
      fSTL_type = TClassEdit::kList;
 
      // Need to override what that set up for fValue and fVal.
      if( fValue ) {
         delete fValue.exchange( nullptr );
      }
      if( fVal )   delete fVal;
      fValue = new TGenCollectionProxy::Value( eltname.c_str(), false );
      fVal   = new TGenCollectionProxy::Value( *fValue );
      fClass = cl;
 
      // This container pretends to hold objects, not pointers:
      fPointers = kFALSE;
 
      // Remember that the initialisation succeeded:
      fInitialized = kTRUE;
      return this;
   }

   void TDVCollectionProxy::FindOffsets( const char* elttype,
                                         const char* conttype ) {
 
      // Start by assuming no offsets.
      fContoff = 0;
      fOffset = 0;
 
      // Find its TClass.
      TClass* dvclass = TClass::GetClass( conttype );
      if( ! dvclass ) {
         ::Fatal( "xAOD::TDVCollectionProxy::FindOffsets",
                  "Cannot find class %s", conttype );
         return;
      }
 
      // Find the TClass for the base DataVector class.
      TClass* dvbase = findDVBase( dvclass );
      if( ! dvbase ) {
         TClass* elclass = classFromDVClass( dvclass );
         if( ! elclass ) {
            ::Fatal( "xAOD::TDVCollectionProxy::FindOffsets",
                     "Couldn't find element type of %s",
                     dvclass->GetName() );
            return;
         }
         fEltBase = elclass;
         fEltType = fEltBase;
 
         // No inheritance --- offsets are zero.
         return;
      }
 
      // Find the container offset.
      fContoff = safeGetBaseOffset( dvclass, dvbase );
 
      // Now, find the base and derived element classes.
      std::string elttype2 = elttype;
      if( elttype2[ elttype2.size() - 1 ] == '*' ) {
         elttype2.erase( elttype2.size() - 1 );
      }
      fEltType = TClass::GetClass( elttype2.c_str() );
      fEltBase = classFromDVClass( dvbase );
 
      if( ( ! fEltType ) || ( ! fEltBase ) ) {
         ::Fatal( "xAOD::TDVCollectionProxy::FindOffsets",
                  "Couldn't find dictionaries for DV element "
                  "type(s) for %s", conttype );
         return;
      }
 
      // Get the offset needed for the pointer operations:
      fOffset = safeGetBaseOffset( fEltType, fEltBase );
 
      return;
   }
 
} // namespace xAOD