Logo ROOT   6.08/07
Reference Guide
TLeafObject.cxx
Go to the documentation of this file.
1 // @(#)root/tree:$Id$
2 // Author: Rene Brun 27/01/96
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TLeafObject
13 \ingroup tree
14 
15 A TLeaf for a general object derived from TObject.
16 */
17 
18 #include "TLeafObject.h"
19 #include "TBranch.h"
20 #include "TBuffer.h"
21 #include "TClass.h"
22 #include "TMethodCall.h"
23 #include "TDataType.h"
24 
26 
27 ////////////////////////////////////////////////////////////////////////////////
28 /// Default constructor for LeafObject.
29 
31 {
32  fClass = 0;
33  fObjAddress = 0;
34  fVirtual = kTRUE;
35 }
36 
37 ////////////////////////////////////////////////////////////////////////////////
38 /// Create a LeafObject.
39 
40 TLeafObject::TLeafObject(TBranch *parent, const char *name, const char *type)
41  :TLeaf(parent, name,type)
42 {
43  SetTitle(type);
44  fClass = TClass::GetClass(type);
45  fObjAddress = 0;
46  fVirtual = kTRUE;
47 }
48 
49 ////////////////////////////////////////////////////////////////////////////////
50 /// Default destructor for a LeafObject.
51 
53 {
54 }
55 
56 ////////////////////////////////////////////////////////////////////////////////
57 /// Pack leaf elements in Basket output buffer.
58 
60 {
61  if (!fObjAddress) return;
62  TObject *object = GetObject();
63  if (object) {
64  if (fVirtual) {
65  UChar_t n = strlen(object->ClassName());
66  b << n;
67  b.WriteFastArray(object->ClassName(),n+1);
68  }
69  object->Streamer(b);
70  } else {
71  if (fClass) {
72  if (fClass->Property() & kIsAbstract) object = new TObject;
73  else object = (TObject *)fClass->New();
74  object->SetBit(kInvalidObject);
75  object->SetUniqueID(123456789);
76  object->Streamer(b);
77  if (fClass->Property() & kIsAbstract) delete object;
78  else fClass->Destructor(object);
79  } else {
80  Error("FillBasket","Attempt to write a NULL object in leaf:%s",GetName());
81  }
82  }
83 }
84 
85 ////////////////////////////////////////////////////////////////////////////////
86 /// Returns pointer to method corresponding to name.
87 ///
88 /// name is a string with the general form "method(list of params)"
89 /// If list of params is omitted, () is assumed;
90 
92 {
93  char *namecpy = new char[strlen(name)+1];
94  strcpy(namecpy,name);
95  char *params = strchr(namecpy,'(');
96  if (params) { *params = 0; params++; }
97  else params = (char *) ")";
98 
100  TMethodCall *m = new TMethodCall(fClass, namecpy, params);
101  delete [] namecpy;
102  if (m->GetMethod()) return m;
103  Error("GetMethodCall","Unknown method:%s",name);
104  delete m;
105  return 0;
106 }
107 
108 ////////////////////////////////////////////////////////////////////////////////
109 /// Returns name of leaf type.
110 
111 const char *TLeafObject::GetTypeName() const
112 {
113  return fTitle.Data();
114 }
115 
116 ////////////////////////////////////////////////////////////////////////////////
117 /// This method must be overridden to handle object notifcation.
118 
120 {
122  return kFALSE;
123 }
124 
125 ////////////////////////////////////////////////////////////////////////////////
126 /// Prints leaf value.
127 
129 {
130  printf("%lx\n",(Long_t)GetValuePointer());
131 }
132 
133 ////////////////////////////////////////////////////////////////////////////////
134 /// Read leaf elements from Basket input buffer.
135 
137 {
138  char classname[128];
139  UChar_t n;
140  if (fVirtual) {
141  b >> n;
142  b.ReadFastArray(classname,n+1);
143  fClass = TClass::GetClass(classname);
144  }
145  if (fClass) {
146  TObject *object;
147  if (!fObjAddress) {
148  Long_t *voidobj = new Long_t[1];
149  fObjAddress = (void **)voidobj;
150  *fObjAddress = (TObject *)fClass->New();
151  }
152  object = (TObject*)(*fObjAddress);
153  if (fBranch->IsAutoDelete()) {
154  fClass->Destructor(object);
155  object = (TObject *)fClass->New();
156  }
157  if (!object) return;
158 
159  if (fClass->GetState() > TClass::kEmulated) {
160  object->Streamer(b);
161  } else {
162  //emulated class has no Streamer
163  if (!TestBit(kWarn)) {
164  Warning("ReadBasket","%s::Streamer not available, using TClass::ReadBuffer instead",fClass->GetName());
165  SetBit(kWarn);
166  }
167  fClass->ReadBuffer(b,object);
168  }
169  // in case we had written a null pointer a Zombie object was created
170  // we must delete it
171  if (object->TestBit(kInvalidObject)) {
172  if (object->GetUniqueID() == 123456789) {
173  fClass->Destructor(object);
174  object = 0;
175  }
176  }
177  *fObjAddress = object;
178  } else GetBranch()->SetAddress(0);
179 }
180 
181 ////////////////////////////////////////////////////////////////////////////////
182 /// Set leaf buffer data address.
183 
184 void TLeafObject::SetAddress(void *add)
185 {
186  fObjAddress = (void **)add;
187 }
188 
189 ////////////////////////////////////////////////////////////////////////////////
190 /// Stream an object of class TLeafObject.
191 
192 void TLeafObject::Streamer(TBuffer &b)
193 {
194  if (b.IsReading()) {
195  UInt_t R__s, R__c;
196  Version_t R__v = b.ReadVersion(&R__s, &R__c);
197  if (R__v > 3 || R__v == 2) {
198  b.ReadClassBuffer(TLeafObject::Class(), this, R__v, R__s, R__c);
199  if (R__v == 2) fVirtual = kTRUE;
200  fObjAddress = 0;
202  if (!fClass) Warning("Streamer","Cannot find class:%s",fTitle.Data());
203  return;
204  }
205  //====process old versions before automatic schema evolution
206  TLeaf::Streamer(b);
207  fObjAddress = 0;
209  if (!fClass) Warning("Streamer","Cannot find class:%s",fTitle.Data());
210  if (R__v < 1) fVirtual = kFALSE;
211  if (R__v == 1) fVirtual = kTRUE;
212  if (R__v == 3) b >> fVirtual;
213  //====end of old versions
214 
215  } else {
217  }
218 }
219 
220 ////////////////////////////////////////////////////////////////////////////////
221 /// Return true if this leaf is does not have any sub-branch/leaf.
222 
224 {
226  return kTRUE;
227 }
TString fTitle
Definition: TNamed.h:37
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:37
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:434
Bool_t IsReading() const
Definition: TBuffer.h:83
Bool_t IsOnTerminalBranch() const
Return true if this leaf is does not have any sub-branch/leaf.
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
Bool_t fVirtual
Support for polymorphism, when set classname is written with object.
Definition: TLeafObject.h:40
virtual void SetAddress(void *add)
Set address of this branch.
Definition: TBranch.cxx:2061
short Version_t
Definition: RtypesCore.h:61
TObject * GetObject() const
Definition: TLeafObject.h:52
A TLeaf for a general object derived from TObject.
Definition: TLeafObject.h:35
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:157
Buffer base class used for serializing objects.
Definition: TBuffer.h:42
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kFALSE
Definition: Rtypes.h:92
TClassRef fClass
! pointer to class
Definition: TLeafObject.h:38
const char * Class
Definition: TXMLSetup.cxx:64
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
Int_t ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count)
Function called by the Streamer functions to deserialize information from buffer b into object at p...
Definition: TClass.cxx:6319
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:188
TMethodCall * GetMethodCall(const char *name)
Returns pointer to method corresponding to name.
Definition: TLeafObject.cxx:91
Bool_t IsAutoDelete() const
Return kTRUE if an existing object in a TBranchObject must be deleted.
Definition: TBranch.cxx:1664
EState GetState() const
Definition: TClass.h:443
TObjArray * GetListOfBranches()
Definition: TBranch.h:178
virtual void * GetValuePointer() const
Definition: TLeafObject.h:54
virtual void ReadBasket(TBuffer &b)
Read leaf elements from Basket input buffer.
Method or function calling interface.
Definition: TMethodCall.h:41
if object ctor succeeded but object should not be used
Definition: TObject.h:63
void ** fObjAddress
! Address of Pointer to object
Definition: TLeafObject.h:39
virtual void SetAddress(void *add=0)
Set leaf buffer data address.
void Destructor(void *obj, Bool_t dtorOnly=kFALSE)
Explicitly call destructor for object.
Definition: TClass.cxx:5071
virtual ~TLeafObject()
Default destructor for a LeafObject.
Definition: TLeafObject.cxx:52
unsigned int UInt_t
Definition: RtypesCore.h:42
TMarker * m
Definition: textangle.C:8
Int_t GetEntriesFast() const
Definition: TObjArray.h:66
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:925
Long_t Property() const
Set TObject::fBits and fStreamerType to cache information about the class.
Definition: TClass.cxx:5683
virtual void ReadFastArray(Bool_t *b, Int_t n)=0
virtual void WriteFastArray(const Bool_t *b, Int_t n)=0
virtual void FillBasket(TBuffer &b)
Pack leaf elements in Basket output buffer.
Definition: TLeafObject.cxx:59
long Long_t
Definition: RtypesCore.h:50
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
TFunction * GetMethod()
Returns the TMethod describing the method to be executed.
virtual Bool_t Notify()
This method must be overridden to handle object notifcation.
#define ClassImp(name)
Definition: Rtypes.h:279
int type
Definition: TGX11.cxx:120
virtual void PrintValue(Int_t i=0) const
Prints leaf value.
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition: TClass.cxx:2893
const char * GetTypeName() const
Returns name of leaf type.
Mother of all ROOT objects.
Definition: TObject.h:37
TLeafObject()
Default constructor for LeafObject.
Definition: TLeafObject.cxx:30
TBranch * fBranch
! Pointer to supporting branch (we do not own the branch)
Definition: TLeaf.h:48
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
unsigned char UChar_t
Definition: RtypesCore.h:34
TBranch * GetBranch() const
Definition: TLeaf.h:70
A TTree is a list of TBranches.
Definition: TBranch.h:58
const Bool_t kTRUE
Definition: Rtypes.h:91
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:155
const Int_t n
Definition: legend1.C:16
char name[80]
Definition: TGX11.cxx:109
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:911
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:52
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Definition: TClass.cxx:4714
const char * Data() const
Definition: TString.h:349