swh:1:snp:af87cd67498ef4fe47c76ed3e7caffe5b61facaf
Tip revision: 9f1463e6330c4bef1c40c1203bc53d02098cb9e3 authored by Unknown Author on 13 September 2007, 14:16:35 UTC
This commit was manufactured by cvs2svn to create tag 'v5-17-03a'.
This commit was manufactured by cvs2svn to create tag 'v5-17-03a'.
Tip revision: 9f1463e
TVirtualRefProxy.h
// @(#)root/meta:$Name: $: $Id: TVirtualRefProxy.h,v 1.3 2006/06/29 06:50:42 brun Exp $
// Author: Markus Frank 20/05/2005
/*************************************************************************
* Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#ifndef ROOT_TVirtualRefProxy
#define ROOT_TVirtualRefProxy
// Framework include files
#ifndef ROOT_Rtypes
#include "Rtypes.h"
#endif // ROOT_Rtypes
// Forward declarations
class TClass;
class TFormLeafInfoReference;
//______________________________________________________________________________
//
// Abstract proxy definition to follow reference objects.
//
//
// Generic Mechanism for Object References
// =======================================
//
// References are a well known mechanism to support persistency
// of entities, which in C++ typically are represented as
// pointers. The generic mechanism allows clients to supply
// hooks to the ROOT framework in interactive mode in order to
// dereference these objects and access the objects pointed to by
// the reference objects.
//
// Implementations are supplied for ROOT own reference mechanism
// based on instances of the TRef and the TRefArray classes.
//
// To support generality this mechanism was implemented using a
// proxy mechanism, which shields the concrete implementation of the
// reference classes from ROOT. Hence, this mechanism also works for
// references as they are supported by the POOL persistency framework
// and by frameworks like Gaudi.
//
// To enable reference support a concrete sub-class instance of
// the TVirtualRefProxy base class must be attached to the TClass
// instance representing the reference itself. Please see the
// header- and implementation file TRefProxy.h/cxx for details.
// For ROOT's own references this is done simply by a call like:
//
// #include "TROOT.h"
// #include "TClass.h"
// #include "TRefProxy.h"
//
// ...
// gROOT->GetClass("TRef")->AdoptReferenceProxy(new TRefProxy());
//
// - GetObject() must return the pointer to the referenced
// object. TTreeFormula then figures out how to access the
// value to be plotted.
// Hence, the actual work is done inside a call to:
//
// void* TRefProxy::GetObject(TFormLeafInfoReference* info, void* data, int)
// {
// if ( data ) {
// TRef* ref = (TRef*)((char*)data + info->GetOffset());
// // Dereference TRef and return pointer to object
// void* obj = ref->GetObject();
// if ( obj ) { return obj; }
//
// ... else handle error or implement failover ....
//
//
// The type of the referenced object must either be known at compilation
// time or it must be possible to guess it reading the first TTree entry.
// In this case the following conditions must be met:
// - GetValueClass() must return the TClass to the referenced
// objects (or a base class)
//
//______________________________________________________________________________
class TVirtualRefProxy {
public:
// Virtual Destructor
virtual ~TVirtualRefProxy() {};
// Release the reference proxy (virtual destructor)
virtual void Release() = 0;
// Clone the reference proxy (virtual constructor)
virtual TVirtualRefProxy* Clone() const = 0;
// Setter of reference class (executed when the proxy is adopted)
// Setup the reference when it is adopted by the TClass structure
//
// classptr [IN] Pointer to the reference class.
virtual void SetClass(TClass *classptr) = 0;
// Getter of reference class.
// The function returns the class description of the reference class
// ie. in the case of TRef TRef::Class
virtual TClass * GetClass() const = 0;
// Access to the target class.
// In the event the value class cannot be specified from the reference
// itself, because the object behind the reference requires a cast,
// the return value must be NULL.
//
// data [IN] Resolved pointer to the referenced object
virtual TClass* GetValueClass(void* data) const = 0;
// Update (and propagate) cached information
virtual Bool_t Update() = 0;
// Flag to indicate if this is a container reference
virtual Bool_t HasCounter() const = 0;
// Access to container size (if container reference (ie TRefArray) etc)
//
// info [IN] Pointer to the structure called by TTree::Draw
// to extract the required object information.
// data [IN] Pointer to the reference object
//
// return value: The prepared pointer to the reference.
virtual Int_t GetCounterValue(TFormLeafInfoReference* info, void *data) = 0;
// Prepare reused reference object (e.g. ZERO data pointers)
// Because TTree::Draw reuses objects some reference implementations
// require setup. For example the pointer to the object the reference points to
// needs to be ZEROed.
//
// data [IN] Pointer to the reference object
//
// return value: The prepared pointer to the reference.
virtual void* GetPreparedReference(void* data) = 0;
// Access referenced object(-data)
//
// info [IN] Pointer to the structure called by TTree::Draw
// to extract the required object information.
// data [IN] Pointer to the referenced object
// instance [IN] Item number if ref collection
//
// return value: Pointer to the requested information
virtual void* GetObject(TFormLeafInfoReference* info, void* data, int instance) = 0;
};
#endif // ROOT_TVirtualRefProxy