AddDVProxy.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
#ifndef XAODCORE_ADDDVPROXY_H
#define XAODCORE_ADDDVPROXY_H
 
// STL include(s):
#include <vector>
#include <set>
 
// ROOT include(s):
#include <TClass.h>
#include <TError.h>
#include <TInterpreter.h>
 
// EDM include(s):
#include "AthContainers/DataVector.h"
 
// Local include(s):
#include "xAODCore/tools/TDVCollectionProxy.h"

#define ADD_DV_PROXY( TYPE )                                            \
   namespace ROOT {                                                     \
      TGenericClassInfo* GenerateInitInstance( const TYPE* );           \
   }                                                                    \
   int register_##TYPE##_CollectionProxy() {                            \
      xAOD::AddDVProxy::add< TYPE >( ROOT::GenerateInitInstance( ( TYPE* ) 0x0 ) ); \
      return 1;                                                         \
   }                                                                    \
   static int _R__UNIQUE_( dummy_##TYPE##_Var ) =                       \
                        register_##TYPE##_CollectionProxy();            \
   R__UseDummy( _R__UNIQUE_( dummy_##TYPE##_Var ) )

#define ADD_NS_DV_PROXY( NS, TYPE )                                     \
   namespace ROOT {                                                     \
      TGenericClassInfo* GenerateInitInstance( const NS::TYPE* );       \
   }                                                                    \
   int register_##NS##_##TYPE##_CollectionProxy() {                     \
      xAOD::AddDVProxy::add< NS::TYPE >( ROOT::GenerateInitInstance( ( NS::TYPE* ) 0x0 ) ); \
      return 1;                                                         \
   }                                                                    \
   static int _R__UNIQUE_( dummy_##NS##_##TYPE##_Var ) =                \
                        register_##NS##_##TYPE##_CollectionProxy();     \
   R__UseDummy( _R__UNIQUE_( dummy_##NS##_##TYPE##_Var ) )
 
namespace xAOD {

   class AddDVProxy {
 
   private:
      template< class T >
      struct Helper {

         typedef T Cont_t;
         typedef typename Cont_t::base_value_type Value_t;

         static void resize( void* obj, size_t size )  {
 
            // Cast the container to the right type:
            Cont_t* c = reinterpret_cast< Cont_t* >( obj );
 
            // Detach the DataVector from its auxiliary store:
            c->setStore( ( SG::IAuxStore* ) 0 );
 
            // Resize the container:
            c->resize( size );
 
            // Make sure that all elements exist and are usable:
            for( size_t i = 0; i < size; ++i ) {
 
               // If the element already exists, we're done:
               if( ( *c )[ i ] ) continue;
 
               // Create a new element:
               ( *c )[ i ] = new Value_t();
            }
 
            return;
         }
 
      }; // struct Helper

      static void loadDictionaries();
 
   public:
      template < typename T >
      static void add( ROOT::TGenericClassInfo* clInfo ) {
 
         // Load the minimal amount of required dictionaries:
         loadDictionaries();
 
         // Create the collection proxy instance:
         TDVCollectionProxy* proxy =
            new TDVCollectionProxy( ClassName< T >::name().c_str() );
         proxy->SetResize( Helper< T >::resize );
 
         // Add it to the class info:
         clInfo->AdoptCollectionProxy( proxy );
 
         return;
      }
 
   }; // struct AddDVProxy
 
} // namespace xAOD
 
#endif // XAODCORE_ADDDVPROXY_H