xAOD::TDVCollectionProxy Class Reference

A Root collection proxy for DataVector containers. More...

#include <TDVCollectionProxy.h>

Inheritance diagram for xAOD::TDVCollectionProxy:

Collaboration diagram for xAOD::TDVCollectionProxy:

Public Types
typedef TGenCollectionProxy::Sizing_t	Sizing_t
	Make the definition of Sizing_t public.

Public Member Functions
	TDVCollectionProxy (const char *conttype)
	Constructor.
	TDVCollectionProxy (const TDVCollectionProxy &rhs)
	Copy constructor.
virtual void	PushProxy (void *objstart)
	Start working with a new collection.
virtual TVirtualCollectionProxy *	Generate () const
	Clone this object.
void	SetResize (Sizing_t func)
	Set the resize(...) function used by the proxy.

Private Member Functions
virtual TGenCollectionProxy *	InitializeEx (Bool_t silent)
	Function initialising the proxy just in time.
void	FindOffsets (const char *elttype, const char *conttype)
	Initialize the cached pointer offsets.
TDVCollectionProxy &	operator= (const TDVCollectionProxy &)

Private Attributes
TString	fName
	Name of the container that this class proxies.
Bool_t	fInitialized
	Flag for knowing whether the class was initialised already.
ptrdiff_t	fContoff
	The offset of the underlying DataVector in the declared type.
ptrdiff_t	fOffset
	Offset between the DV base pointer and the full DV pointer.
TClass *	fEltBase
	The element type to which the DV representation points.
TClass *	fEltType
	The declared element type of the DV.

Detailed Description

A Root collection proxy for DataVector containers.

In order for a container type to be treated properly by TTree::Draw and friends, Root must recognize that it is in fact a container type, and generate an appropriate proxy for it. This doesn't happen automatically, though. This class serves as an appropriate proxy for DataVector classes. Like the Root proxy classes, it's based on making a hard cast to a dummy DataVector type. But because DataVector's can inherit, we need to be careful about pointer conversions, something the Root proxy classes could ignore. We extend the Root environment buffer to cache information about the pointer offsets.

Author

Scott Snyder Scott.nosp@m..Sny.nosp@m.der@c.nosp@m.ern..nosp@m.ch

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Revision

687822

Date

2015-08-06 09:58:06 +0200 (Thu, 06 Aug 2015)

Definition at line 45 of file TDVCollectionProxy.h.

Member Typedef Documentation

Sizing_t

typedef TGenCollectionProxy::Sizing_t xAOD::TDVCollectionProxy::Sizing_t

Make the definition of Sizing_t public.

Definition at line 50 of file TDVCollectionProxy.h.

Constructor & Destructor Documentation

TDVCollectionProxy() [1/2]

TDVCollectionProxy::TDVCollectionProxy

(

const char *

conttype

)

Constructor.

Parameters

conttype

The name of the container type we're proxying. Note that this may be different from a DataVector of elttype for classes which derive from DataVector.

Definition at line 332 of file TDVCollectionProxy.cxx.

      : 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() [2/2]

TDVCollectionProxy::TDVCollectionProxy

(

const TDVCollectionProxy &

rhs

)

Copy constructor.

Parameters

rhs	The proxy to copy.

Definition at line 374 of file TDVCollectionProxy.cxx.

      : 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;
         }
      }
   }

Member Function Documentation

FindOffsets()

void TDVCollectionProxy::FindOffsets ( const char * elttype, const char * conttype )

private

Initialize the cached pointer offsets.

Suppose we have D deriving from B, and thus DataVector<D> deriving from DataVector<B>. In general, inheritance may be multiple or virtual, so we need to adjust the pointer offsets.

Suppose we're setting up the proxy for DataVector<D>. Then fContoff will be set to the offset of the DataVector<B> base within DataVector<D> — this is the amount we need to shift the container pointer by before applying the proxy. Originally, we cached an offset for the element conversions as well. But that doesn't work for the case of virtual derivation. Instead, we save the Reflex types for the base and derived types, and use Reflex to convert. (We can get away with caching the offset for the container because we know what the fully-derived type will be. We don't know that for the elements.)

Parameters

elttype	The name of the contained type (including a trailing '*').
conttype	The name of the container type we're proxying. Note that this may be different from a DataVector of elttype for classes which derive from DataVector.

Definition at line 533 of file TDVCollectionProxy.cxx.

                                                                {
 
      // 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;
   }

Generate()

TVirtualCollectionProxy * TDVCollectionProxy::Generate ( ) const

virtual

Clone this object.

Definition at line 432 of file TDVCollectionProxy.cxx.

                                                               {
 
      return new TDVCollectionProxy( *this );
   }

InitializeEx()

TGenCollectionProxy * TDVCollectionProxy::InitializeEx ( Bool_t silent )

privatevirtual

Function initialising the proxy just in time.

Definition at line 449 of file TDVCollectionProxy.cxx.

                                                                        {
 
      // 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;
      }
      /*
       * CID 20575: (#1 of 1): String converted to C pointer then back to string 
       * (UNNECESSARY_STRING_COPY)
       * string_to_ptr_and_back: In eltname.c_str(), a C++ string is converted to 
       * a C-style pointer, then passed to a function that uses this pointer to construct 
       * one or more strings.
      */
      // Find the container and element offsets.
      //coverity[UNNECESSARY_STRING_COPY]
      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 = ROOT::kSTLlist;
 
      // 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;
   }

operator=()

TDVCollectionProxy & xAOD::TDVCollectionProxy::operator= ( const TDVCollectionProxy & )

private

PushProxy()

virtual void xAOD::TDVCollectionProxy::PushProxy ( void * objstart )

virtual

Start working with a new collection.

Parameters

objstart

The address of the collection.

SetResize()

void TDVCollectionProxy::SetResize

(

Sizing_t

func

)

Set the resize(...) function used by the proxy.

The resize(...) functions need to be specific for the different classes.

This function is used to supply a specific resize(...) function for this proxy's class.

Parameters

func	The function to use

Definition at line 443 of file TDVCollectionProxy.cxx.

                                                     {
 
      fResize = func;
      return;
   }

Member Data Documentation

fContoff

ptrdiff_t xAOD::TDVCollectionProxy::fContoff

private

The offset of the underlying DataVector in the declared type.

Definition at line 85 of file TDVCollectionProxy.h.

fEltBase

TClass* xAOD::TDVCollectionProxy::fEltBase

private

The element type to which the DV representation points.

Definition at line 90 of file TDVCollectionProxy.h.

fEltType

TClass* xAOD::TDVCollectionProxy::fEltType

private

The declared element type of the DV.

Definition at line 92 of file TDVCollectionProxy.h.

fInitialized

Bool_t xAOD::TDVCollectionProxy::fInitialized

private

Flag for knowing whether the class was initialised already.

Definition at line 82 of file TDVCollectionProxy.h.

fName

TString xAOD::TDVCollectionProxy::fName

private

Name of the container that this class proxies.

Definition at line 80 of file TDVCollectionProxy.h.

fOffset

ptrdiff_t xAOD::TDVCollectionProxy::fOffset

private

Offset between the DV base pointer and the full DV pointer.

Definition at line 87 of file TDVCollectionProxy.h.

---

The documentation for this class was generated from the following files:

• TDVCollectionProxy.h
• TDVCollectionProxy.cxx