Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TBufferIO.cxx
Go to the documentation of this file.
1// @(#)root/io:$Id$
2// Author: Sergey Linev 21/02/2018
3
4/*************************************************************************
5 * Copyright (C) 1995-2018, 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/**
13\file TBufferIO.cxx
14\class TBufferIO
15\ingroup IO
16
17Direct subclass of TBuffer, implements common methods for TBufferFile and TBufferText classes
18*/
19
20#include "TBufferIO.h"
21
22#include "TExMap.h"
23#include "TClass.h"
24#include "TFile.h"
25#include "TError.h"
26#include "TClonesArray.h"
27#include "TStreamerInfo.h"
28#include "TStreamerElement.h"
29#include "TArrayC.h"
30#include "TRefTable.h"
31#include "TProcessID.h"
32#include "TVirtualMutex.h"
33#include "TInterpreter.h"
34#include "TROOT.h"
35
37
38
39////////////////////////////////////////////////////////////////////////////////
40/// constructor
41
46
47////////////////////////////////////////////////////////////////////////////////
48/// constructor
49
54
55////////////////////////////////////////////////////////////////////////////////
56/// constructor
57
63
64////////////////////////////////////////////////////////////////////////////////
65/// destructor
66
68{
69 delete fMap;
70 delete fClassMap;
71}
72
73////////////////////////////////////////////////////////////////////////////////
74/// Return the version number of the owner file.
75
77{
78 TFile *file = (TFile *)GetParent();
79 if (file)
80 return file->GetVersion();
81 else
82 return 0;
83}
84
85////////////////////////////////////////////////////////////////////////////////
86/// Set the initial size of the map used to store object and class
87/// references during reading. The default size is TBufferFile::kMapSize.
88/// Increasing the default has the benefit that when reading many
89/// small objects the map does not need to be resized too often
90/// (the system is always dynamic, even with the default everything
91/// will work, only the initial resizing will cost some time).
92/// This method can only be called directly after the creation of
93/// the TBuffer, before any reading is done. Globally this option
94/// can be changed using SetGlobalReadParam().
97{
99 R__ASSERT(fMap == nullptr);
100
102}
103
104////////////////////////////////////////////////////////////////////////////////
105/// Set the initial size of the hashtable used to store object and class
106/// references during writing. The default size is TBufferFile::kMapSize.
107/// Increasing the default has the benefit that when writing many
108/// small objects the hashtable does not get too many collisions
109/// (the system is always dynamic, even with the default everything
110/// will work, only a large number of collisions will cost performance).
111/// For optimal performance hashsize should always be a prime.
112/// This method can only be called directly after the creation of
113/// the TBuffer, before any writing is done. Globally this option
114/// can be changed using SetGlobalWriteParam().
115
117{
119 R__ASSERT(fMap == nullptr);
120
122}
123
124////////////////////////////////////////////////////////////////////////////////
125/// Create the fMap container and initialize them
126/// with the null object.
127
129{
130 if (IsWriting()) {
131 if (!fMap) {
132 fMap = new TExMap(fMapSize);
133 // No need to keep track of the class in write mode
134 // fClassMap = new TExMap(fMapSize);
135 fMapCount = 0;
136 }
137 } else {
138 if (!fMap) {
139 fMap = new TExMap(fMapSize);
140 fMap->Add(0, kNullTag); // put kNullTag in slot 0
141 fMapCount = 1;
142 } else if (fMapCount == 0) {
143 fMap->Add(0, kNullTag); // put kNullTag in slot 0
144 fMapCount = 1;
145 }
146 if (!fClassMap) {
148 fClassMap->Add(0, kNullTag); // put kNullTag in slot 0
149 }
150 }
151}
152
153////////////////////////////////////////////////////////////////////////////////
154/// Add object to the fMap container.
155///
156/// If obj is not 0 add object to the map (in read mode also add 0 objects to
157/// the map). This method may only be called outside this class just before
158/// calling obj->Streamer() to prevent self reference of obj, in case obj
159/// contains (via via) a pointer to itself. In that case offset must be 1
160/// (default value for offset).
161
163{
164 if (IsWriting()) {
165 if (!fMap)
166 InitMap();
167
168 if (obj) {
170 ULong_t hash = Void_Hash(obj);
171 fMap->Add(hash, (Longptr_t)obj, offset);
172 // No need to keep track of the class in write mode
173 // fClassMap->Add(hash, (Longptr_t)obj, (Longptr_t)((TObject*)obj)->IsA());
174 fMapCount++;
175 }
176 } else {
177 if (!fMap || !fClassMap)
178 InitMap();
179
180 fMap->Add(offset, (Longptr_t)obj);
181 fClassMap->Add(offset, (obj && obj != (TObject *)-1) ? (Longptr_t)((TObject *)obj)->IsA() : 0);
182 fMapCount++;
183 }
184}
185
186////////////////////////////////////////////////////////////////////////////////
187/// Add object to the fMap container.
188///
189/// If obj is not 0 add object to the map (in read mode also add 0 objects to
190/// the map). This method may only be called outside this class just before
191/// calling obj->Streamer() to prevent self reference of obj, in case obj
192/// contains (via via) a pointer to itself. In that case offset must be 1
193/// (default value for offset).
194
195void TBufferIO::MapObject(const void *obj, const TClass *cl, UInt_t offset)
196{
197 if (IsWriting()) {
198 if (!fMap)
199 InitMap();
200
201 if (obj) {
203 ULong_t hash = Void_Hash(obj);
204 fMap->Add(hash, (Longptr_t)obj, offset);
205 // No need to keep track of the class in write mode
206 // fClassMap->Add(hash, (Longptr_t)obj, (Longptr_t)cl);
207 fMapCount++;
208 }
209 } else {
210 if (!fMap || !fClassMap)
211 InitMap();
212
213 fMap->Add(offset, (Longptr_t)obj);
215 fMapCount++;
216 }
217}
218
219////////////////////////////////////////////////////////////////////////////////
220/// Check if the specified object is already in the buffer.
221/// Returns kTRUE if object already in the buffer, kFALSE otherwise
222/// (also if obj is 0 or TBuffer not in writing mode).
223
225{
226 return CheckObject(obj, TObject::Class());
227}
228
229////////////////////////////////////////////////////////////////////////////////
230/// Check if the specified object of the specified class is already in
231/// the buffer. Returns kTRUE if object already in the buffer,
232/// kFALSE otherwise (also if obj is 0 ).
233
235{
236 if (!obj || !fMap || !ptrClass)
237 return kFALSE;
238
239 TClass *clActual = ptrClass->GetActualClass(obj);
240
241 ULongptr_t idx;
242
243 if (clActual && (ptrClass != clActual)) {
244 const char *temp = (const char *)obj;
245 temp -= clActual->GetBaseClassOffset(ptrClass);
246 idx = (ULongptr_t)fMap->GetValue(Void_Hash(temp), (Longptr_t)temp);
247 } else {
248 idx = (ULongptr_t)fMap->GetValue(Void_Hash(obj), (Longptr_t)obj);
249 }
250
251 return idx ? kTRUE : kFALSE;
252}
253
254////////////////////////////////////////////////////////////////////////////////
255/// Retrieve the object stored in the buffer's object map at 'tag'
256/// Set ptr and ClassPtr respectively to the address of the object and
257/// a pointer to its TClass.
258
259void TBufferIO::GetMappedObject(UInt_t tag, void *&ptr, TClass *&ClassPtr) const
260{
261 // original code in TBufferFile is wrong, fMap->GetSize() is just number of entries, cannot be used for tag checks
262
263 // if (tag > (UInt_t)fMap->GetSize()) {
264 // ptr = nullptr;
265 // ClassPtr = nullptr;
266 // } else {
267 ptr = (void *)(Longptr_t)fMap->GetValue(tag);
269 // }
270}
271
272////////////////////////////////////////////////////////////////////////////////////
273/// Returns tag for specified object from objects map (if exists)
274/// Returns 0 if object not included into objects map
275
277{
278 if (!obj || !fMap)
279 return 0;
280
281 return fMap->GetValue(Void_Hash(obj), (Longptr_t)obj);
282}
283
284////////////////////////////////////////////////////////////////////////////////
285/// Delete existing fMap and reset map counter.
286
288{
289 if (fMap)
290 fMap->Delete();
291 if (fClassMap)
292 fClassMap->Delete();
293 fMapCount = 0;
294 fDisplacement = 0;
295
296 // reset user bits
300}
301
302////////////////////////////////////////////////////////////////////////////////
303/// Reset buffer object. Resets map and buffer offset
305{
307 ResetMap();
308}
309
310////////////////////////////////////////////////////////////////////////////////
311/// This offset is used when a key (or basket) is transfered from one
312/// file to the other. In this case the TRef and TObject might have stored a
313/// pid index (to retrieve TProcessIDs) which referred to their order on the original
314/// file, the fPidOffset is to be added to those values to correctly find the
315/// TProcessID. This fPidOffset needs to be increment if the key/basket is copied
316/// and need to be zero for new key/basket.
317
322
323//---- Utilities for TStreamerInfo ----------------------------------------------
324
325////////////////////////////////////////////////////////////////////////////////
326/// force writing the TStreamerInfo to the file
327
329{
330 if (info)
331 info->ForceWriteInfo((TFile *)GetParent(), force);
332}
333
334////////////////////////////////////////////////////////////////////////////////
335/// Make sure TStreamerInfo is not optimized, otherwise it will not be
336/// possible to support schema evolution in read mode.
337/// In case the StreamerInfo has already been computed and optimized,
338/// one must disable the option BypassStreamer.
339
341{
342 TStreamerInfo *sinfo = (TStreamerInfo *)a->GetClass()->GetStreamerInfo();
344}
345
346////////////////////////////////////////////////////////////////////////////////
347/// Mark the classindex of the current file as using this TStreamerInfo
348
350{
351 TFile *file = (TFile *)GetParent();
352 if (file) {
353 TArrayC *cindex = file->GetClassIndex();
354 Int_t nindex = cindex->GetSize();
355 Int_t number = info->GetNumber();
357 Error("TagStreamerInfo", "StreamerInfo: %s number: %d out of range[0,%d] in file: %s", info->GetName(), number,
358 nindex, file->GetName());
359 return;
360 }
361 if (cindex->fArray[number] == 0) {
362 cindex->fArray[0] = 1;
363 cindex->fArray[number] = 1;
364 }
365 }
366}
367
368////////////////////////////////////////////////////////////////////////////////
369/// Interface to TStreamerInfo::ReadBufferClones.
370
372{
373 char **arr = (char **)a->GetObjectRef(0);
374 char **end = arr + nobjects;
375 // a->GetClass()->GetStreamerInfo()->ReadBufferClones(*this,a,nobjects,-1,0);
376 TStreamerInfo *info = (TStreamerInfo *)a->GetClass()->GetStreamerInfo(objvers);
377 // return info->ReadBuffer(*this,arr,-1,nobjects,0,1);
378 return ApplySequenceVecPtr(*(info->GetReadMemberWiseActions(kTRUE)), arr, end);
379}
380
381////////////////////////////////////////////////////////////////////////////////
382/// Interface to TStreamerInfo::WriteBufferClones.
383
385{
386 char **arr = reinterpret_cast<char **>(a->GetObjectRef(0));
387 // a->GetClass()->GetStreamerInfo()->WriteBufferClones(*this,(TClonesArray*)a,nobjects,-1,0);
388 TStreamerInfo *info = (TStreamerInfo *)a->GetClass()->GetStreamerInfo();
389 // return info->WriteBufferAux(*this,arr,-1,nobjects,0,1);
390 char **end = arr + nobjects;
391 // No need to tell call ForceWriteInfo as it by ForceWriteInfoClones.
392 return ApplySequenceVecPtr(*(info->GetWriteMemberWiseActions(kTRUE)), arr, end);
393}
394
395////////////////////////////////////////////////////////////////////////////////
396/// Return the last TProcessID in the file.
397
399{
400 TFile *file = (TFile *)GetParent();
401 // warn if the file contains > 1 PID (i.e. if we might have ambiguity)
402 if (file && !reftable->TestBit(TRefTable::kHaveWarnedReadingOld) && file->GetNProcessIDs() > 1) {
403 Warning("ReadBuffer", "The file was written during several processes with an "
404 "older ROOT version; the TRefTable entries might be inconsistent.");
406 }
407
408 // the file's last PID is the relevant one, all others might have their tables overwritten
410 if (file && file->GetNProcessIDs() > 0) {
411 // take the last loaded PID
413 }
414 return fileProcessID;
415}
416
417////////////////////////////////////////////////////////////////////////////////
418/// The TProcessID with number pidf is read from file.
419/// If the object is not already entered in the gROOT list, it is added.
420
422{
423 TFile *file = (TFile *)GetParent();
424 if (!file) {
425 if (!pidf)
426 return TProcessID::GetPID(); // may happen when cloning an object
427 return nullptr;
428 }
429
430 TProcessID *pid = nullptr;
431 {
432 R__LOCKGUARD_IMT(gInterpreterMutex); // Lock for parallel TTree I/O
433 pid = file->ReadProcessID(pidf);
434 }
435
436 return pid;
437}
438
439////////////////////////////////////////////////////////////////////////////////
440/// Return the exec id stored in the current TStreamerInfo element.
441/// The execid has been saved in the unique id of the TStreamerElement
442/// being read by TStreamerElement::Streamer.
443/// The current element (fgElement) is set as a static global
444/// by TStreamerInfo::ReadBuffer (Clones) when reading this TRef.
445
447{
448 return TStreamerInfo::GetCurrentElement()->GetUniqueID();
449}
450
451////////////////////////////////////////////////////////////////////////////////
452/// Check if the ProcessID pid is already in the file.
453/// If not, add it and return the index number in the local file list.
454
456{
457 TFile *file = (TFile *)GetParent();
458 if (!file)
459 return 0;
460 return file->WriteProcessID(pid);
461}
462
463////////////////////////////////////////////////////////////////////////////////
464
465namespace {
466struct DynamicType {
467 // Helper class to enable typeid on any address
468 // Used in code similar to:
469 // typeid( * (DynamicType*) void_ptr );
470 virtual ~DynamicType() {}
471};
472} // namespace
473
474////////////////////////////////////////////////////////////////////////////////
475/// Write object to I/O buffer.
476///
477/// This function assumes that the value in 'obj' is the value stored in
478/// a pointer to a "ptrClass". The actual type of the object pointed to
479/// can be any class derived from "ptrClass".
480/// Return:
481/// - 0: failure
482/// - 1: success
483/// - 2: truncated success (i.e actual class is missing. Only ptrClass saved.)
484///
485/// If 'cacheReuse' is true (default) upon seeing an object address a second time,
486/// we record the offset where its was written the first time rather than streaming
487/// the object a second time.
488/// If 'cacheReuse' is false, we always stream the object. This allows the (re)use
489/// of temporary object to store different data in the same buffer.
490
491Int_t TBufferIO::WriteObjectAny(const void *obj, const TClass *ptrClass, Bool_t cacheReuse /* = kTRUE */)
492{
493 if (!obj) {
494 WriteObjectClass(nullptr, nullptr, kTRUE);
495 return 1;
496 }
497
498 if (!ptrClass) {
499 Error("WriteObjectAny", "ptrClass argument may not be 0");
500 return 0;
501 }
502
503 TClass *clActual = ptrClass->GetActualClass(obj);
504
505 if (clActual == 0 || clActual->GetState() == TClass::kForwardDeclared) {
506 // The ptrClass is a class with a virtual table and we have no
507 // TClass with the actual type_info in memory.
508
509 DynamicType *d_ptr = (DynamicType *)obj;
510 Warning("WriteObjectAny", "An object of type %s (from type_info) passed through a %s pointer was truncated (due "
511 "a missing dictionary)!!!",
512 typeid(*d_ptr).name(), ptrClass->GetName());
514 return 2;
515 } else if (clActual && (clActual != ptrClass)) {
516 const char *temp = (const char *)obj;
517 temp -= clActual->GetBaseClassOffset(ptrClass);
519 return 1;
520 } else {
522 return 1;
523 }
524}
525
526////////////////////////////////////////////////////////////////////////////////
527/// Write object to I/O buffer.
528
533
534//---- Static functions --------------------------------------------------------
535
536////////////////////////////////////////////////////////////////////////////////
537/// Set the initial size of the map used to store object and class
538/// references during reading.
539///
540/// The default size is kMapSize.
541/// Increasing the default has the benefit that when reading many
542/// small objects the array does not need to be resized too often
543/// (the system is always dynamic, even with the default everything
544/// will work, only the initial resizing will cost some time).
545/// Per TBuffer object this option can be changed using SetReadParam().
546
551
552////////////////////////////////////////////////////////////////////////////////
553/// Set the initial size of the map used to store object and class
554/// references during reading.
555///
556/// The default size is kMapSize.
557/// Increasing the default has the benefit that when reading many
558/// small objects the array does not need to be resized too often
559/// (the system is always dynamic, even with the default everything
560/// will work, only the initial resizing will cost some time).
561/// Per TBuffer object this option can be changed using SetReadParam().
562
567
568////////////////////////////////////////////////////////////////////////////////
569/// Get default read map size.
570
575
576////////////////////////////////////////////////////////////////////////////////
577/// Get default write map size.
578
#define a(i)
Definition RSha256.hxx:99
unsigned short UShort_t
Unsigned Short integer 2 bytes (unsigned short)
Definition RtypesCore.h:54
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
long Longptr_t
Integer large enough to hold a pointer (platform-dependent)
Definition RtypesCore.h:89
short Version_t
Class version identifier (short)
Definition RtypesCore.h:79
unsigned long ULong_t
Unsigned long integer 4 bytes (unsigned long). Size depends on architecture.
Definition RtypesCore.h:69
unsigned long ULongptr_t
Unsigned integer large enough to hold a pointer (platform-dependent)
Definition RtypesCore.h:90
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:125
Option_t Option_t cindex
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char mode
R__EXTERN TVirtualMutex * gInterpreterMutex
char *(* ReAllocCharFun_t)(char *, size_t, size_t)
Definition TStorage.h:30
#define R__LOCKGUARD_IMT(mutex)
Array of chars or bytes (8 bits per element).
Definition TArrayC.h:27
void SetWriteParam(Int_t mapsize) override
Set the initial size of the hashtable used to store object and class references during writing.
static void SetGlobalReadParam(Int_t mapsize)
Set the initial size of the map used to store object and class references during reading.
void Reset() override
Reset buffer object. Resets map and buffer offset.
void InitMap() override
Create the fMap container and initialize them with the null object.
TClass * IsA() const override
Definition TBufferIO.h:120
Int_t GetVersionOwner() const override
Return the version number of the owner file.
Definition TBufferIO.cxx:76
static void SetGlobalWriteParam(Int_t mapsize)
Set the initial size of the map used to store object and class references during reading.
TProcessID * GetLastProcessID(TRefTable *reftable) const override
Return the last TProcessID in the file.
void ForceWriteInfo(TVirtualStreamerInfo *info, Bool_t force) override
force writing the TStreamerInfo to the file
void ForceWriteInfoClones(TClonesArray *a) override
Make sure TStreamerInfo is not optimized, otherwise it will not be possible to support schema evoluti...
virtual void WriteObjectClass(const void *actualObjStart, const TClass *actualClass, Bool_t cacheReuse)=0
TExMap * fMap
Map containing object,offset pairs for reading/writing.
Definition TBufferIO.h:39
void SetReadParam(Int_t mapsize) override
Set the initial size of the map used to store object and class references during reading.
Definition TBufferIO.cxx:96
Bool_t CheckObject(const TObject *obj) override
Check if the specified object is already in the buffer.
void WriteObject(const TObject *obj, Bool_t cacheReuse=kTRUE) override
Write object to I/O buffer.
void MapObject(const TObject *obj, UInt_t offset=1) override
Add object to the fMap container.
Long64_t GetObjectTag(const void *obj)
Returns tag for specified object from objects map (if exists) Returns 0 if object not included into o...
Int_t WriteClones(TClonesArray *a, Int_t nobjects) override
Interface to TStreamerInfo::WriteBufferClones.
UShort_t WriteProcessID(TProcessID *pid) override
Check if the ProcessID pid is already in the file.
TExMap * fClassMap
Map containing object,class pairs for reading.
Definition TBufferIO.h:40
Int_t fDisplacement
Value to be added to the map offsets.
Definition TBufferIO.h:37
static R__ALWAYS_INLINE ULong_t Void_Hash(const void *ptr)
Return hash value for provided object.
Definition TBufferIO.h:53
virtual void CheckCount(UInt_t)
Definition TBufferIO.h:56
Int_t fMapCount
Number of objects or classes in map.
Definition TBufferIO.h:35
static Int_t GetGlobalReadParam()
Get default read map size.
void TagStreamerInfo(TVirtualStreamerInfo *info) override
Mark the classindex of the current file as using this TStreamerInfo.
static Int_t fgMapSize
Default map size for all TBuffer objects.
Definition TBufferIO.h:42
void ResetMap() override
Delete existing fMap and reset map counter.
TProcessID * ReadProcessID(UShort_t pidf) override
The TProcessID with number pidf is read from file.
~TBufferIO() override
destructor
Definition TBufferIO.cxx:67
UShort_t fPidOffset
Offset to be added to the pid index in this key/buffer.
Definition TBufferIO.h:38
Int_t ReadClones(TClonesArray *a, Int_t nobjects, Version_t objvers) override
Interface to TStreamerInfo::ReadBufferClones.
void GetMappedObject(UInt_t tag, void *&ptr, TClass *&ClassPtr) const override
Retrieve the object stored in the buffer's object map at 'tag' Set ptr and ClassPtr respectively to t...
Int_t WriteObjectAny(const void *obj, const TClass *ptrClass, Bool_t cacheReuse=kTRUE) override
Write object to I/O buffer.
void SetPidOffset(UShort_t offset) override
This offset is used when a key (or basket) is transfered from one file to the other.
Int_t fMapSize
Default size of map.
Definition TBufferIO.h:36
static Int_t GetGlobalWriteParam()
Get default write map size.
UInt_t GetTRefExecId() override
Return the exec id stored in the current TStreamerInfo element.
Buffer base class used for serializing objects.
Definition TBuffer.h:43
virtual Int_t ApplySequenceVecPtr(const TStreamerInfoActions::TActionSequence &sequence, void *start_collection, void *end_collection)=0
TObject * GetParent() const
Return pointer to parent of this buffer.
Definition TBuffer.cxx:261
Bool_t IsWriting() const
Definition TBuffer.h:87
Bool_t IsReading() const
Definition TBuffer.h:86
void SetBufferOffset(Int_t offset=0)
Definition TBuffer.h:93
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
@ kForwardDeclared
Definition TClass.h:127
An array of clone (identical) objects.
This class stores a (key,value) pair using an external hash.
Definition TExMap.h:33
void Add(ULong64_t hash, Long64_t key, Long64_t value)
Add an (key,value) pair to the table. The key should be unique.
Definition TExMap.cxx:87
Long64_t GetValue(ULong64_t hash, Long64_t key)
Return the value belonging to specified key and hash value.
Definition TExMap.cxx:173
void Delete(Option_t *opt="") override
Delete all entries stored in the TExMap.
Definition TExMap.cxx:163
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:131
virtual TProcessID * ReadProcessID(UShort_t pidf)
The TProcessID with number pidf is read from this file.
Definition TFile.cxx:1981
Int_t GetVersion() const
Definition TFile.h:324
TArrayC * GetClassIndex() const
Definition TFile.h:305
virtual Int_t GetNProcessIDs() const
Definition TFile.h:318
virtual UShort_t WriteProcessID(TProcessID *pid)
Check if the ProcessID pidd is already in the file, if not, add it and return the index number in the...
Definition TFile.cxx:3438
TObjArray * GetListOfProcessIDs() const
Definition TFile.h:315
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
TObject * Last() const override
Return the object in the last filled slot. Returns 0 if no entries.
Mother of all ROOT objects.
Definition TObject.h:41
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:1057
static TClass * Class()
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1071
void ResetBit(UInt_t f)
Definition TObject.h:201
A TProcessID identifies a ROOT job in a unique way in time and space.
Definition TProcessID.h:74
static TProcessID * GetProcessID(UShort_t pid)
static function returning a pointer to TProcessID number pid in fgPIDs
static TProcessID * GetPID()
static: returns pointer to current TProcessID
A TRefTable maintains the association between a referenced object and the parent object supporting th...
Definition TRefTable.h:35
@ kHaveWarnedReadingOld
Definition TRefTable.h:63
Describes a persistent version of a class.
static TStreamerElement * GetCurrentElement()
static function returning a pointer to the current TStreamerElement fgElement points to the current T...
Abstract Interface class describing Streamer information for one class.