Proxy class for storing any kind of object. More...

#include <FakeProxy.h>

Collaboration diagram for D3PD::FakeProxy:

Public Member Functions
	FakeProxy (void *object, const std::type_info &ti)
	Constructor taking ownership of an object. More...

	~FakeProxy ()
	Destructor deleting the encapsulated object. More...

void	clear ()
	Clear the contents of this variable. More...

Static Public Member Functions
::TClass *	getClass (const std::type_info &ti)
	Access the dictionary of a specific object. More...

static void *	newPrimitive (const std::type_info &ti)
	Create a new instance of a primitive. More...

static void	deletePrimitive (void *ptr, const std::type_info &ti)
	Delete a primitive. More...

Private Types
enum	ClearType { UNKNOWN, ZERO, CLEAR }
	Variable clearing method. More...

Private Attributes
ClearType	m_clearType
	The variable clearing type for this object. More...

void *	m_object
	The owned object. More...

const std::type_info &	m_type
	The type of the owned object. More...

::TMethodCall	m_clear
	Method calling clear on the object. More...

::TClass *	m_dict
	Dictionary for class types. More...

Detailed Description

Proxy class for storing any kind of object.

   This proxy is used to create and take ownership of object
   types that will not be written out to the D3PD file, but the
   block filler tools still need them to exist in memory.

   The class can handle both primitive and class types.

Author: 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: 487276

Date: 2012-03-08 12:04:56 +0100 (Thu, 08 Mar 2012)

Definition at line 33 of file FakeProxy.h.

Member Enumeration Documentation

◆ ClearType

enum D3PD::FakeProxy::ClearType

private

Variable clearing method.

Primitive types are just zeroed out, while for class types the code checks if they have a clear() function. If they do, it will be used to clear the variable.

Enumerator
UNKNOWN	Can't clear the variable.
ZERO	Clear the variable by filling it with zeroes.
CLEAR	Clear the variable by calling clear() on it.

Definition at line 58 of file FakeProxy.h.

                      {
          UNKNOWN, 
          ZERO,    
          CLEAR    
       };

Constructor & Destructor Documentation

◆ FakeProxy()

D3PD::FakeProxy::FakeProxy	(	void *	object,
		const std::type_info &	ti
	)

Constructor taking ownership of an object.

The constructor figures out how the variable will need to be cleared later on event by event.

It issues a warning if it didn't manage to do so. (It's not an error condition not to be able to clear the variable...)

Parameters

object	Pointer to the object the proxy is to take posession of
ti	The type info of the object

Definition at line 28 of file FakeProxy.cxx.

       : m_clearType( ZERO ), m_object( object ), m_type( ti ),
         m_clear(), m_dict( 0 ) {
  
       // Handle the case when it's an object that we received:
       m_dict = getClass( m_type );
       if( m_dict ) {
          // Check if there is a "clear" function defined for this object:
          TMethodCall method( m_dict, "clear", "" );
          if( method.IsValid() ) {
             m_clearType = CLEAR;
             m_clear = method;
          }
       }
    }

◆ ~FakeProxy()

D3PD::FakeProxy::~FakeProxy ( )

Destructor deleting the encapsulated object.

The destructor tries to free the memory allocated by the object in the correct way.

Definition at line 48 of file FakeProxy.cxx.

                          {
  
       if( m_dict && m_object ) {
          m_dict->Destructor( m_object );
       } else if( m_object ) {
          deletePrimitive( m_object, m_type );
       }
    }

Member Function Documentation

◆ clear()

void D3PD::FakeProxy::clear ( )

Clear the contents of this variable.

This function also uses the dictionary of the object to try to clear it.

For primitive types we don't do anything for now...

Definition at line 61 of file FakeProxy.cxx.

                          {
  
       // Execute the clear function if it is defined:
       if( m_clearType == CLEAR ) {
          m_clear.Execute( m_object );
       }
  
       return;
    }

◆ deletePrimitive()

void D3PD::FakeProxy::deletePrimitive	(	void *	ptr,
		const std::type_info &	ti
	)

static

Delete a primitive.

This function is used to delete previously created primitive types from memory.

Parameters

ptr	Pointer to the primitive object
ti	The type info for the primitive type

Definition at line 140 of file FakeProxy.cxx.

                                                                       {
  
       if( ti == typeid( bool ) ) {
          delete reinterpret_cast< bool* >( ptr );
       } else if ( ti == typeid( char ) ) {
          delete reinterpret_cast< char* >( ptr );
       } else if ( ti == typeid( short ) ) {
          delete reinterpret_cast< short* >( ptr );
       } else if ( ti == typeid( unsigned short ) ) {
          delete reinterpret_cast< unsigned short* >( ptr );
       } else if ( ti == typeid( int ) ) {
          delete reinterpret_cast< int* >( ptr );
       } else if ( ti == typeid( unsigned int ) ) {
          delete reinterpret_cast< unsigned int* >( ptr );
       } else if ( ti == typeid( long ) ) {
          delete reinterpret_cast< long* >( ptr );
       } else if ( ti == typeid( unsigned long ) ) {
          delete reinterpret_cast< unsigned long* >( ptr );
       } else if ( ti == typeid( unsigned long long ) ) {
          delete reinterpret_cast< unsigned long long* >( ptr );
       } else if ( ti == typeid( float ) ) {
          delete reinterpret_cast< float* >( ptr );
       } else if ( ti == typeid( double ) ) {
          delete reinterpret_cast< double* >( ptr );
       } else {
          REPORT_MESSAGE_WITH_CONTEXT( MSG::WARNING, "D3PD::FakeProxy" )
             << "Couldn't delete type: " << ti.name() << "; There is a mistake "
             << "in the code!";
       }
  
       return;
    }

◆ getClass()

TClass * D3PD::FakeProxy::getClass ( const std::type_info & ti )

static

Access the dictionary of a specific object.

I took this implementation basically from D3PD::RootD3PD, as I needed the same functionality here as well.

Parameters

ti	The type info of the type in question

Returns: A dictionary for the type if found, or a zero pointer if it's not

Definition at line 79 of file FakeProxy.cxx.

                                                        {
  
       TClass* cls = gROOT->GetClass( ti );
       if( ! cls ) {
          cls = gROOT->GetClass( System::typeinfoName( ti ).c_str() );
       }
  
       if( ! cls ) {
          REPORT_MESSAGE_WITH_CONTEXT( MSG::DEBUG, "D3PD::FakeProxy" )
             << "Can't find class for typeinfo " << ti.name();
       }
  
       return cls;
    }

◆ newPrimitive()

void * D3PD::FakeProxy::newPrimitive ( const std::type_info & ti )

static

Create a new instance of a primitive.

This function is used to create a new primitive type in memory.

Parameters

ti	The type info for the primitive type

Returns: A pointer to the newly created primitive, or a null pointer if the type is not known.

Definition at line 101 of file FakeProxy.cxx.

                                                          {
  
       if( ti == typeid( bool ) ) {
          return new bool;
       } else if ( ti == typeid( char ) ) {
          return new char;
       } else if ( ti == typeid( short ) ) {
          return new short;
       } else if ( ti == typeid( unsigned short ) ) {
          return new unsigned short;
       } else if ( ti == typeid( int ) ) {
          return new int;
       } else if ( ti == typeid( unsigned int ) ) {
          return new unsigned int;
       } else if ( ti == typeid( long ) ) {
          return new long;
       } else if ( ti == typeid( unsigned long ) ) {
          return new unsigned long;
       } else if ( ti == typeid( unsigned long long ) ) {
          return new unsigned long long;
       } else if ( ti == typeid( float ) ) {
          return new float;
       } else if ( ti == typeid( double ) ) {
          return new double;
       }
  
       REPORT_MESSAGE_WITH_CONTEXT( MSG::WARNING, "D3PD::FakeProxy" )
          << "Type '" << ti.name() << "' is not a known primitive";
  
       return 0;
    }

Member Data Documentation

◆ m_clear

::TMethodCall D3PD::FakeProxy::m_clear

private

Method calling clear on the object.

Definition at line 67 of file FakeProxy.h.

◆ m_clearType

ClearType D3PD::FakeProxy::m_clearType

private

The variable clearing type for this object.

Definition at line 63 of file FakeProxy.h.

◆ m_dict

::TClass* D3PD::FakeProxy::m_dict

private

Dictionary for class types.

Definition at line 68 of file FakeProxy.h.

◆ m_object

void* D3PD::FakeProxy::m_object

private

The owned object.

Definition at line 65 of file FakeProxy.h.

◆ m_type

const std::type_info& D3PD::FakeProxy::m_type

private

The type of the owned object.

Definition at line 66 of file FakeProxy.h.

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

Public Member Functions

Static Public Member Functions

Private Types

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ClearType

Constructor & Destructor Documentation

◆ FakeProxy()

◆ ~FakeProxy()

Member Function Documentation

◆ clear()

◆ deletePrimitive()

◆ getClass()

◆ newPrimitive()

Member Data Documentation

◆ m_clear

◆ m_clearType

◆ m_dict

◆ m_object

◆ m_type