Logo ROOT  
Reference Guide
TObject.cxx
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Rene Brun 26/12/94
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 TObject
13\ingroup Base
14
15Mother of all ROOT objects.
16
17The TObject class provides default behaviour and protocol for all
18objects in the ROOT system. It provides protocol for object I/O,
19error handling, sorting, inspection, printing, drawing, etc.
20Every object which inherits from TObject can be stored in the
21ROOT collection classes.
22
23TObject's bits can be used as flags, bits 0 - 13 and 24-31 are
24reserved as global bits while bits 14 - 23 can be used in different
25class hierarchies (watch out for overlaps).
26*/
27
28#include <cstring>
29#if !defined(WIN32) && !defined(__MWERKS__) && !defined(R__SOLARIS)
30#include <strings.h>
31#endif
32#include <cstdlib>
33#include <cstdio>
34#include <sstream>
35#include <fstream>
36#include <iostream>
37
38#include "Varargs.h"
39#include "snprintf.h"
40#include "TObject.h"
41#include "TBuffer.h"
42#include "TClass.h"
43#include "TGuiFactory.h"
44#include "TMethod.h"
45#include "TROOT.h"
46#include "TError.h"
47#include "TObjectTable.h"
48#include "TVirtualPad.h"
49#include "TInterpreter.h"
50#include "TMemberInspector.h"
51#include "TRefTable.h"
52#include "TProcessID.h"
53
56
58
59#if defined(__clang__) || defined (__GNUC__)
60# define ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
61#else
62# define ATTRIBUTE_NO_SANITIZE_ADDRESS
63#endif
64
65namespace ROOT {
66namespace Internal {
67
68// Return true if delete changes/poisons/taints the memory.
69//
70// Detect whether operator delete taints the memory. If it does, we can not rely
71// on TestBit(kNotDeleted) to check if the memory has been deleted (but in case,
72// like TClonesArray, where we know the destructor will be called but not operator
73// delete, we can still use it to detect the cases where the destructor was called.
74
77{
78 static constexpr UInt_t kGoldenUUID = 0x00000021;
79 static constexpr UInt_t kGoldenbits = 0x03000000;
80
81 TObject *o = new TObject;
82 o->SetUniqueID(kGoldenUUID);
83 UInt_t *o_fuid = &(o->fUniqueID);
84 UInt_t *o_fbits = &(o->fBits);
85
86 if (*o_fuid != kGoldenUUID) {
87 Error("CheckingDeleteSideEffects",
88 "fUniqueID is not as expected, we got 0x%.8x instead of 0x%.8x",
89 *o_fuid, kGoldenUUID);
90 }
91 if (*o_fbits != kGoldenbits) {
92 Error("CheckingDeleteSideEffects",
93 "fBits is not as expected, we got 0x%.8x instead of 0x%.8x",
94 *o_fbits, kGoldenbits);
95 }
96 if (gDebug >= 9) {
97 unsigned char *oc = reinterpret_cast<unsigned char *>(o); // for address calculations
98 unsigned char references[sizeof(TObject)];
99 memcpy(references, oc, sizeof(TObject));
100
101 // The effective part of this code (the else statement is just that without
102 // any of the debug statement)
103 delete o;
104
105 // Not using the error logger, as there routine is meant to be called
106 // during library initialization/loading.
107 fprintf(stderr,
108 "DEBUG: Checking before and after delete the content of a TObject with uniqueID 0x21\n");
109 for(size_t i = 0; i < sizeof(TObject); i += 4) {
110 fprintf(stderr, "DEBUG: 0x%.8x vs 0x%.8x\n", *(int*)(references +i), *(int*)(oc + i));
111 }
112 } else
113 delete o; // the 'if' part is that surrounded by the debug code.
114
115 // Intentionally accessing the deleted memory to check whether it has been changed as
116 // a consequence (side effect) of executing operator delete. If there no change, we
117 // can guess this is always the case and we can rely on the changes to fBits made
118 // by ~TObject to detect use-after-delete error (and print a message rather than
119 // stop the program with a segmentation fault)
120 if ( *o_fbits != 0x01000000 ) {
121 // operator delete tainted the memory, we can not rely on TestBit(kNotDeleted)
122 return true;
123 }
124 return false;
125}
126
128{
129 static const bool value = DeleteChangesMemoryImpl();
130 if (gDebug >= 9)
131 DeleteChangesMemoryImpl(); // To allow for printing the debug info
132 return value;
133}
134
135}} // ROOT::Detail
136
137////////////////////////////////////////////////////////////////////////////////
138/// Copy this to obj.
139
140void TObject::Copy(TObject &obj) const
141{
142 obj.fUniqueID = fUniqueID; // when really unique don't copy
143 if (obj.IsOnHeap()) { // test uses fBits so don't move next line
144 obj.fBits = fBits;
145 obj.fBits |= kIsOnHeap;
146 } else {
147 obj.fBits = fBits;
148 obj.fBits &= ~kIsOnHeap;
149 }
150 obj.fBits &= ~kIsReferenced;
151 obj.fBits &= ~kCanDelete;
152}
153
154////////////////////////////////////////////////////////////////////////////////
155/// TObject destructor. Removes object from all canvases and object browsers
156/// if observer bit is on and remove from the global object table.
157
160 // if (!TestBit(kNotDeleted))
161 // Fatal("~TObject", "object deleted twice");
162
164
165 fBits &= ~kNotDeleted;
166
168}
169
170////////////////////////////////////////////////////////////////////////////////
171/// Private helper function which will dispatch to
172/// TObjectTable::AddObj.
173/// Included here to avoid circular dependency between header files.
174
176{
178}
179
180////////////////////////////////////////////////////////////////////////////////
181/// Append graphics object to current pad. In case no current pad is set
182/// yet, create a default canvas with the name "c1".
183
185{
186 if (!gPad) {
187 gROOT->MakeDefCanvas();
188 }
189 if (!gPad->IsEditable()) return;
191 gPad->GetListOfPrimitives()->Add(this,option);
192 gPad->Modified(kTRUE);
193}
194
195////////////////////////////////////////////////////////////////////////////////
196/// Browse object. May be overridden for another default action
197
199{
200 //Inspect();
201 TClass::AutoBrowse(this,b);
202}
203
204////////////////////////////////////////////////////////////////////////////////
205/// Returns name of class to which the object belongs.
206
207const char *TObject::ClassName() const
208{
209 return IsA()->GetName();
210}
211
212////////////////////////////////////////////////////////////////////////////////
213/// Make a clone of an object using the Streamer facility.
214/// If the object derives from TNamed, this function is called
215/// by TNamed::Clone. TNamed::Clone uses the optional argument to set
216/// a new name to the newly created object.
217///
218/// If the object class has a DirectoryAutoAdd function, it will be
219/// called at the end of the function with the parameter gDirectory.
220/// This usually means that the object will be appended to the current
221/// ROOT directory.
222
223TObject *TObject::Clone(const char *) const
224{
225 if (gDirectory) {
226 return gDirectory->CloneObject(this);
227 } else {
228 // Some of the streamer (eg. roofit's) expect(ed?) a valid gDirectory during streaming.
229 return gROOT->CloneObject(this);
230 }
231}
232
233////////////////////////////////////////////////////////////////////////////////
234/// Compare abstract method. Must be overridden if a class wants to be able
235/// to compare itself with other objects. Must return -1 if this is smaller
236/// than obj, 0 if objects are equal and 1 if this is larger than obj.
237
239{
240 AbstractMethod("Compare");
241 return 0;
242}
243
244////////////////////////////////////////////////////////////////////////////////
245/// Delete this object. Typically called as a command via the interpreter.
246/// Normally use "delete" operator when object has been allocated on the heap.
247
249{
250 if (IsOnHeap()) {
251 // Delete object from CINT symbol table so it can not be used anymore.
252 // CINT object are always on the heap.
253 gInterpreter->DeleteGlobal(this);
254
255 delete this;
256 }
257}
258
259
260////////////////////////////////////////////////////////////////////////////////
261/// Computes distance from point (px,py) to the object.
262/// This member function must be implemented for each graphics primitive.
263/// This default function returns a big number (999999).
264
266{
267 // AbstractMethod("DistancetoPrimitive");
268 return 999999;
269}
270
271////////////////////////////////////////////////////////////////////////////////
272/// Default Draw method for all objects
273
275{
277}
278
279////////////////////////////////////////////////////////////////////////////////
280/// Draw class inheritance tree of the class to which this object belongs.
281/// If a class B inherits from a class A, description of B is drawn
282/// on the right side of description of A.
283/// Member functions overridden by B are shown in class A with a blue line
284/// crossing-out the corresponding member function.
285/// The following picture is the class inheritance tree of class TPaveLabel:
286///
287/// \image html base_object.png
288
290{
291 IsA()->Draw();
292}
293
294////////////////////////////////////////////////////////////////////////////////
295/// Draw a clone of this object in the current selected pad for instance with:
296/// `gROOT->SetSelectedPad(gPad)`.
297
299{
300 TVirtualPad *pad = gROOT->GetSelectedPad();
301 TVirtualPad *padsav = gPad;
302 if (pad) pad->cd();
303
304 TObject *newobj = Clone();
305 if (!newobj) return nullptr;
306 if (pad) {
307 if (option && *option)
308 pad->GetListOfPrimitives()->Add(newobj, option);
309 else
310 pad->GetListOfPrimitives()->Add(newobj, GetDrawOption());
311 pad->Modified(kTRUE);
312 pad->Update();
313 if (padsav) padsav->cd();
314 return newobj;
315 }
316 if (option && *option)
317 newobj->Draw(option);
318 else
319 newobj->Draw(GetDrawOption());
320 if (padsav) padsav->cd();
321
322 return newobj;
323}
324
325////////////////////////////////////////////////////////////////////////////////
326/// Dump contents of object on stdout.
327/// Using the information in the object dictionary (class TClass)
328/// each data member is interpreted.
329/// If a data member is a pointer, the pointer value is printed
330///
331/// The following output is the Dump of a TArrow object:
332/// ~~~ {.cpp}
333/// fAngle 0 Arrow opening angle (degrees)
334/// fArrowSize 0.2 Arrow Size
335/// fOption.*fData
336/// fX1 0.1 X of 1st point
337/// fY1 0.15 Y of 1st point
338/// fX2 0.67 X of 2nd point
339/// fY2 0.83 Y of 2nd point
340/// fUniqueID 0 object unique identifier
341/// fBits 50331648 bit field status word
342/// fLineColor 1 line color
343/// fLineStyle 1 line style
344/// fLineWidth 1 line width
345/// fFillColor 19 fill area color
346/// fFillStyle 1001 fill area style
347/// ~~~
348
349void TObject::Dump() const
350{
351 // Get the actual address of the object.
352 const void *actual = IsA()->DynamicCast(TObject::Class(),this,kFALSE);
353 IsA()->Dump(actual);
354}
355
356////////////////////////////////////////////////////////////////////////////////
357/// Execute method on this object with the given parameter string, e.g.
358/// "3.14,1,\"text\"".
359
360void TObject::Execute(const char *method, const char *params, Int_t *error)
361{
362 if (!IsA()) return;
363
364 Bool_t must_cleanup = TestBit(kMustCleanup);
365
366 gInterpreter->Execute(this, IsA(), method, params, error);
367
368 if (gPad && must_cleanup) gPad->Modified();
369}
370
371////////////////////////////////////////////////////////////////////////////////
372/// Execute method on this object with parameters stored in the TObjArray.
373/// The TObjArray should contain an argv vector like:
374/// ~~~ {.cpp}
375/// argv[0] ... argv[n] = the list of TObjString parameters
376/// ~~~
377
378void TObject::Execute(TMethod *method, TObjArray *params, Int_t *error)
379{
380 if (!IsA()) return;
381
382 Bool_t must_cleanup = TestBit(kMustCleanup);
383
384 gInterpreter->Execute(this, IsA(), method, params, error);
385
386 if (gPad && must_cleanup) gPad->Modified();
387}
388
389
390////////////////////////////////////////////////////////////////////////////////
391/// Execute action corresponding to an event at (px,py). This method
392/// must be overridden if an object can react to graphics events.
393
395{
396 // AbstractMethod("ExecuteEvent");
397}
398
399////////////////////////////////////////////////////////////////////////////////
400/// Must be redefined in derived classes.
401/// This function is typically used with TCollections, but can also be used
402/// to find an object by name inside this object.
403
404TObject *TObject::FindObject(const char *) const
405{
406 return nullptr;
407}
408
409////////////////////////////////////////////////////////////////////////////////
410/// Must be redefined in derived classes.
411/// This function is typically used with TCollections, but can also be used
412/// to find an object inside this object.
413
415{
416 return nullptr;
417}
418
419////////////////////////////////////////////////////////////////////////////////
420/// Get option used by the graphics system to draw this object.
421/// Note that before calling object.GetDrawOption(), you must
422/// have called object.Draw(..) before in the current pad.
423
425{
426 if (!gPad) return "";
427
428 TListIter next(gPad->GetListOfPrimitives());
429 while (auto obj = next()) {
430 if (obj == this)
431 return next.GetOption();
432 }
433 return "";
434}
435
436////////////////////////////////////////////////////////////////////////////////
437/// Returns name of object. This default method returns the class name.
438/// Classes that give objects a name should override this method.
439
440const char *TObject::GetName() const
441{
442 return IsA()->GetName();
443}
444
445////////////////////////////////////////////////////////////////////////////////
446/// Returns mime type name of object. Used by the TBrowser (via TGMimeTypes
447/// class). Override for class of which you would like to have different
448/// icons for objects of the same class.
449
450const char *TObject::GetIconName() const
451{
452 return nullptr;
453}
454
455////////////////////////////////////////////////////////////////////////////////
456/// Return the unique object id.
457
459{
460 return fUniqueID;
461}
462
463////////////////////////////////////////////////////////////////////////////////
464/// Returns string containing info about the object at position (px,py).
465/// This method is typically overridden by classes of which the objects
466/// can report peculiarities for different positions.
467/// Returned string will be re-used (lock in MT environment).
468
470{
471 if (!gPad) return (char*)"";
472 static char info[64];
473 Float_t x = gPad->AbsPixeltoX(px);
474 Float_t y = gPad->AbsPixeltoY(py);
475 snprintf(info,64,"x=%g, y=%g",gPad->PadtoX(x),gPad->PadtoY(y));
476 return info;
477}
478
479////////////////////////////////////////////////////////////////////////////////
480/// Returns title of object. This default method returns the class title
481/// (i.e. description). Classes that give objects a title should override
482/// this method.
483
484const char *TObject::GetTitle() const
485{
486 return IsA()->GetTitle();
487}
488
489
490////////////////////////////////////////////////////////////////////////////////
491/// Execute action in response of a timer timing out. This method
492/// must be overridden if an object has to react to timers.
493
495{
496 return kFALSE;
497}
498
499////////////////////////////////////////////////////////////////////////////////
500/// Return hash value for this object.
501///
502/// Note: If this routine is overloaded in a derived class, this derived class
503/// should also add
504/// ~~~ {.cpp}
505/// ROOT::CallRecursiveRemoveIfNeeded(*this)
506/// ~~~
507/// Otherwise, when RecursiveRemove is called (by ~TObject or example) for this
508/// type of object, the transversal of THashList and THashTable containers will
509/// will have to be done without call Hash (and hence be linear rather than
510/// logarithmic complexity). You will also see warnings like
511/// ~~~
512/// Error in <ROOT::Internal::TCheckHashRecursiveRemoveConsistency::CheckRecursiveRemove>: The class SomeName overrides TObject::Hash but does not call TROOT::RecursiveRemove in its destructor.
513/// ~~~
514///
515
517{
518 //return (ULong_t) this >> 2;
519 const void *ptr = this;
520 return TString::Hash(&ptr, sizeof(void*));
521}
522
523////////////////////////////////////////////////////////////////////////////////
524/// Returns kTRUE if object inherits from class "classname".
525
526Bool_t TObject::InheritsFrom(const char *classname) const
527{
528 return IsA()->InheritsFrom(classname);
529}
530
531////////////////////////////////////////////////////////////////////////////////
532/// Returns kTRUE if object inherits from TClass cl.
533
535{
536 return IsA()->InheritsFrom(cl);
537}
538
539////////////////////////////////////////////////////////////////////////////////
540/// Dump contents of this object in a graphics canvas.
541/// Same action as Dump but in a graphical form.
542/// In addition pointers to other objects can be followed.
543///
544/// The following picture is the Inspect of a histogram object:
545/// \image html base_inspect.png
546
548{
549 gGuiFactory->CreateInspectorImp(this, 400, 200);
550}
551
552////////////////////////////////////////////////////////////////////////////////
553/// Returns kTRUE in case object contains browsable objects (like containers
554/// or lists of other objects).
555
557{
558 return kFALSE;
559}
560
561////////////////////////////////////////////////////////////////////////////////
562/// Default equal comparison (objects are equal if they have the same
563/// address in memory). More complicated classes might want to override
564/// this function.
565
567{
568 return obj == this;
569}
570
571////////////////////////////////////////////////////////////////////////////////
572/// The ls function lists the contents of a class on stdout. Ls output
573/// is typically much less verbose then Dump().
574
576{
578 std::cout <<"OBJ: " << IsA()->GetName() << "\t" << GetName() << "\t" << GetTitle() << " : ";
579 std::cout << Int_t(TestBit(kCanDelete));
580 if (option && strstr(option,"noaddr")==nullptr) {
581 std::cout <<" at: "<< this ;
582 }
583 std::cout << std::endl;
584}
585
586////////////////////////////////////////////////////////////////////////////////
587/// This method must be overridden to handle object notification.
588
590{
591 return kFALSE;
592}
593
594////////////////////////////////////////////////////////////////////////////////
595/// This method must be overridden if a class wants to paint itself.
596/// The difference between Paint() and Draw() is that when a object
597/// draws itself it is added to the display list of the pad in
598/// which it is drawn (and automatically redrawn whenever the pad is
599/// redrawn). While paint just draws the object without adding it to
600/// the pad display list.
601
603{
604 // AbstractMethod("Paint");
605}
606
607////////////////////////////////////////////////////////////////////////////////
608/// Pop on object drawn in a pad to the top of the display list. I.e. it
609/// will be drawn last and on top of all other primitives.
610
612{
613 if (!gPad) return;
614
615 if (this == gPad->GetListOfPrimitives()->Last()) return;
616
617 TListIter next(gPad->GetListOfPrimitives());
618 while (auto obj = next())
619 if (obj == this) {
620 TString opt = next.GetOption();
621 gPad->GetListOfPrimitives()->Remove((TObject*)this);
622 gPad->GetListOfPrimitives()->AddLast(this, opt.Data());
623 gPad->Modified();
624 return;
625 }
626}
627
628////////////////////////////////////////////////////////////////////////////////
629/// This method must be overridden when a class wants to print itself.
630
632{
633 std::cout <<"OBJ: " << IsA()->GetName() << "\t" << GetName() << "\t" << GetTitle() << std::endl;
634}
635
636////////////////////////////////////////////////////////////////////////////////
637/// Read contents of object with specified name from the current directory.
638/// First the key with the given name is searched in the current directory,
639/// next the key buffer is deserialized into the object.
640/// The object must have been created before via the default constructor.
641/// See TObject::Write().
642
644{
645 if (gDirectory)
646 return gDirectory->ReadTObject(this,name);
647 return 0;
648}
649
650////////////////////////////////////////////////////////////////////////////////
651/// Recursively remove this object from a list. Typically implemented
652/// by classes that can contain multiple references to a same object.
653
655{
656}
657
658
659////////////////////////////////////////////////////////////////////////////////
660/// Save this object in the file specified by filename.
661///
662/// - if "filename" contains ".root" the object is saved in filename as root
663/// binary file.
664///
665/// - if "filename" contains ".xml" the object is saved in filename as a xml
666/// ascii file.
667///
668/// - if "filename" contains ".cc" the object is saved in filename as C code
669/// independant from ROOT. The code is generated via SavePrimitive().
670/// Specific code should be implemented in each object to handle this
671/// option. Like in TF1::SavePrimitive().
672///
673/// - otherwise the object is written to filename as a CINT/C++ script. The
674/// C++ code to rebuild this object is generated via SavePrimitive(). The
675/// "option" parameter is passed to SavePrimitive. By default it is an empty
676/// string. It can be used to specify the Draw option in the code generated
677/// by SavePrimitive.
678///
679/// The function is available via the object context menu.
680
681void TObject::SaveAs(const char *filename, Option_t *option) const
682{
683 //==============Save object as a root file===================================
684 if (filename && strstr(filename,".root")) {
685 if (gDirectory) gDirectory->SaveObjectAs(this,filename,"");
686 return;
687 }
688
689 //==============Save object as a XML file====================================
690 if (filename && strstr(filename,".xml")) {
691 if (gDirectory) gDirectory->SaveObjectAs(this,filename,"");
692 return;
693 }
694
695 //==============Save object as a JSON file================================
696 if (filename && strstr(filename,".json")) {
697 if (gDirectory) gDirectory->SaveObjectAs(this,filename,option);
698 return;
699 }
700
701 //==============Save object as a C, ROOT independant, file===================
702 if (filename && strstr(filename,".cc")) {
703 TString fname;
704 if (filename && strlen(filename) > 0) {
705 fname = filename;
706 } else {
707 fname.Form("%s.cc", GetName());
708 }
709 std::ofstream out;
710 out.open(fname.Data(), std::ios::out);
711 if (!out.good ()) {
712 Error("SaveAs", "cannot open file: %s", fname.Data());
713 return;
714 }
715 ((TObject*)this)->SavePrimitive(out,"cc");
716 out.close();
717 Info("SaveAs", "cc file: %s has been generated", fname.Data());
718 return;
719 }
720
721 //==============Save as a C++ CINT file======================================
722 TString fname;
723 if (filename && strlen(filename) > 0) {
724 fname = filename;
725 } else {
726 fname.Form("%s.C", GetName());
727 }
728 std::ofstream out;
729 out.open(fname.Data(), std::ios::out);
730 if (!out.good ()) {
731 Error("SaveAs", "cannot open file: %s", fname.Data());
732 return;
733 }
734 out <<"{"<<std::endl;
735 out <<"//========= Macro generated from object: "<<GetName()<<"/"<<GetTitle()<<std::endl;
736 out <<"//========= by ROOT version"<<gROOT->GetVersion()<<std::endl;
737 ((TObject*)this)->SavePrimitive(out,option);
738 out <<"}"<<std::endl;
739 out.close();
740 Info("SaveAs", "C++ Macro file: %s has been generated", fname.Data());
741}
742
743////////////////////////////////////////////////////////////////////////////////
744/// Save a primitive as a C++ statement(s) on output stream "out".
745
746void TObject::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
747{
748 out << "//Primitive: " << GetName() << "/" << GetTitle()
749 <<". You must implement " << ClassName() << "::SavePrimitive" << std::endl;
750}
751
752////////////////////////////////////////////////////////////////////////////////
753/// Set drawing option for object. This option only affects
754/// the drawing style and is stored in the option field of the
755/// TObjOptLink supporting a TPad's primitive list (TList).
756/// Note that it does not make sense to call object.SetDrawOption(option)
757/// before having called object.Draw().
758
760{
761 if (!gPad || !option) return;
762
763 TListIter next(gPad->GetListOfPrimitives());
764 delete gPad->FindObject("Tframe");
765 while (auto obj = next())
766 if (obj == this) {
767 next.SetOption(option);
768 return;
769 }
770}
771
772////////////////////////////////////////////////////////////////////////////////
773/// Set or unset the user status bits as specified in f.
774
776{
777 if (set)
778 SetBit(f);
779 else
780 ResetBit(f);
781}
782
783////////////////////////////////////////////////////////////////////////////////
784/// Set the unique object id.
785
787{
788 fUniqueID = uid;
789}
790
791////////////////////////////////////////////////////////////////////////////////
792/// Set current style settings in this object
793/// This function is called when either TCanvas::UseCurrentStyle
794/// or TROOT::ForceStyle have been invoked.
795
797{
798}
799
800////////////////////////////////////////////////////////////////////////////////
801/// Write this object to the current directory.
802/// The data structure corresponding to this object is serialized.
803/// The corresponding buffer is written to the current directory
804/// with an associated key with name "name".
805///
806/// Writing an object to a file involves the following steps:
807///
808/// - Creation of a support TKey object in the current directory.
809/// The TKey object creates a TBuffer object.
810///
811/// - The TBuffer object is filled via the class::Streamer function.
812///
813/// - If the file is compressed (default) a second buffer is created to
814/// hold the compressed buffer.
815///
816/// - Reservation of the corresponding space in the file by looking
817/// in the TFree list of free blocks of the file.
818///
819/// - The buffer is written to the file.
820///
821/// Bufsize can be given to force a given buffer size to write this object.
822/// By default, the buffersize will be taken from the average buffer size
823/// of all objects written to the current file so far.
824///
825/// If a name is specified, it will be the name of the key.
826/// If name is not given, the name of the key will be the name as returned
827/// by GetName().
828///
829/// The option can be a combination of: kSingleKey, kOverwrite or kWriteDelete
830/// Using the kOverwrite option a previous key with the same name is
831/// overwritten. The previous key is deleted before writing the new object.
832/// Using the kWriteDelete option a previous key with the same name is
833/// deleted only after the new object has been written. This option
834/// is safer than kOverwrite but it is slower.
835/// NOTE: Neither kOverwrite nor kWriteDelete reduces the size of a TFile--
836/// the space is simply freed up to be overwritten; in the case of a TTree,
837/// it is more complicated. If one opens a TTree, appends some entries,
838/// then writes it out, the behaviour is effectively the same. If, however,
839/// one creates a new TTree and writes it out in this way,
840/// only the metadata is replaced, effectively making the old data invisible
841/// without deleting it. TTree::Delete() can be used to mark all disk space
842/// occupied by a TTree as free before overwriting its metadata this way.
843/// The kSingleKey option is only used by TCollection::Write() to write
844/// a container with a single key instead of each object in the container
845/// with its own key.
846///
847/// An object is read from the file into memory via TKey::Read() or
848/// via TObject::Read().
849///
850/// The function returns the total number of bytes written to the file.
851/// It returns 0 if the object cannot be written.
852
853Int_t TObject::Write(const char *name, Int_t option, Int_t bufsize) const
854{
856 return 0;
857
858 TString opt = "";
859 if (option & kSingleKey) opt += "SingleKey";
860 if (option & kOverwrite) opt += "OverWrite";
861 if (option & kWriteDelete) opt += "WriteDelete";
862
863 if (gDirectory)
864 return gDirectory->WriteTObject(this,name,opt.Data(),bufsize);
865
866 const char *objname = name ? name : GetName();
867 Error("Write","The current directory (gDirectory) is null. The object (%s) has not been written.",objname);
868 return 0;
869}
870
871////////////////////////////////////////////////////////////////////////////////
872/// Write this object to the current directory. For more see the
873/// const version of this method.
874
876{
877 return ((const TObject*)this)->Write(name, option, bufsize);
878}
879
880////////////////////////////////////////////////////////////////////////////////
881/// Stream an object of class TObject.
882
884{
885 if (IsA()->CanIgnoreTObjectStreamer()) return;
886 UShort_t pidf;
887 if (R__b.IsReading()) {
888 R__b.SkipVersion(); // Version_t R__v = R__b.ReadVersion(); if (R__v) { }
889 R__b >> fUniqueID;
890 R__b >> fBits;
891 fBits |= kIsOnHeap; // by definition de-serialized object is on heap
892 if (TestBit(kIsReferenced)) {
893 //if the object is referenced, we must read its old address
894 //and store it in the ProcessID map in gROOT
895 R__b >> pidf;
896 pidf += R__b.GetPidOffset();
897 TProcessID *pid = R__b.ReadProcessID(pidf);
898 if (pid) {
899 UInt_t gpid = pid->GetUniqueID();
900 if (gpid>=0xff) {
901 fUniqueID = fUniqueID | 0xff000000;
902 } else {
903 fUniqueID = ( fUniqueID & 0xffffff) + (gpid<<24);
904 }
905 pid->PutObjectWithID(this);
906 }
907 }
908 } else {
910 if (!TestBit(kIsReferenced)) {
911 R__b << fUniqueID;
912 R__b << fBits;
913 } else {
914 //if the object is referenced, we must save its address/file_pid
915 UInt_t uid = fUniqueID & 0xffffff;
916 R__b << uid;
917 R__b << fBits;
919 //add uid to the TRefTable if there is one
921 if(table) table->Add(uid, pid);
922 pidf = R__b.WriteProcessID(pid);
923 R__b << pidf;
924 }
925 }
926}
927
928////////////////////////////////////////////////////////////////////////////////
929/// Interface to ErrorHandler (protected).
930
931void TObject::DoError(int level, const char *location, const char *fmt, va_list va) const
932{
933 const char *classname = "UnknownClass";
934 if (TROOT::Initialized())
935 classname = ClassName();
936
937 ::ErrorHandler(level, Form("%s::%s", classname, location), fmt, va);
938}
939
940////////////////////////////////////////////////////////////////////////////////
941/// Issue info message. Use "location" to specify the method where the
942/// warning occurred. Accepts standard printf formatting arguments.
943
944void TObject::Info(const char *location, const char *va_(fmt), ...) const
945{
946 va_list ap;
947 va_start(ap, va_(fmt));
948 DoError(kInfo, location, va_(fmt), ap);
949 va_end(ap);
950}
951
952////////////////////////////////////////////////////////////////////////////////
953/// Issue warning message. Use "location" to specify the method where the
954/// warning occurred. Accepts standard printf formatting arguments.
955
956void TObject::Warning(const char *location, const char *va_(fmt), ...) const
957{
958 va_list ap;
959 va_start(ap, va_(fmt));
960 DoError(kWarning, location, va_(fmt), ap);
961 va_end(ap);
962 if (TROOT::Initialized())
963 gROOT->Message(1001, this);
964}
965
966////////////////////////////////////////////////////////////////////////////////
967/// Issue error message. Use "location" to specify the method where the
968/// error occurred. Accepts standard printf formatting arguments.
969
970void TObject::Error(const char *location, const char *va_(fmt), ...) const
971{
972 va_list ap;
973 va_start(ap, va_(fmt));
974 DoError(kError, location, va_(fmt), ap);
975 va_end(ap);
976 if (TROOT::Initialized())
977 gROOT->Message(1002, this);
978}
979
980////////////////////////////////////////////////////////////////////////////////
981/// Issue system error message. Use "location" to specify the method where
982/// the system error occurred. Accepts standard printf formatting arguments.
983
984void TObject::SysError(const char *location, const char *va_(fmt), ...) const
985{
986 va_list ap;
987 va_start(ap, va_(fmt));
988 DoError(kSysError, location, va_(fmt), ap);
989 va_end(ap);
990 if (TROOT::Initialized())
991 gROOT->Message(1003, this);
992}
993
994////////////////////////////////////////////////////////////////////////////////
995/// Issue fatal error message. Use "location" to specify the method where the
996/// fatal error occurred. Accepts standard printf formatting arguments.
997
998void TObject::Fatal(const char *location, const char *va_(fmt), ...) const
999{
1000 va_list ap;
1001 va_start(ap, va_(fmt));
1002 DoError(kFatal, location, va_(fmt), ap);
1003 va_end(ap);
1004 if (TROOT::Initialized())
1005 gROOT->Message(1004, this);
1006}
1007
1008////////////////////////////////////////////////////////////////////////////////
1009/// Use this method to implement an "abstract" method that you don't
1010/// want to leave purely abstract.
1011
1012void TObject::AbstractMethod(const char *method) const
1013{
1014 Warning(method, "this method must be overridden!");
1015}
1016
1017////////////////////////////////////////////////////////////////////////////////
1018/// Use this method to signal that a method (defined in a base class)
1019/// may not be called in a derived class (in principle against good
1020/// design since a child class should not provide less functionality
1021/// than its parent, however, sometimes it is necessary).
1022
1023void TObject::MayNotUse(const char *method) const
1024{
1025 Warning(method, "may not use this method");
1026}
1027
1028////////////////////////////////////////////////////////////////////////////////
1029/// Use this method to declare a method obsolete. Specify as of which version
1030/// the method is obsolete and as from which version it will be removed.
1031
1032void TObject::Obsolete(const char *method, const char *asOfVers, const char *removedFromVers) const
1033{
1034 const char *classname = "UnknownClass";
1035 if (TROOT::Initialized())
1036 classname = ClassName();
1037
1038 ::Obsolete(Form("%s::%s", classname, method), asOfVers, removedFromVers);
1039}
1040
1041////////////////////////////////////////////////////////////////////////////////
1042/// Get status of object stat flag.
1043
1045{
1046 return fgObjectStat;
1047}
1048////////////////////////////////////////////////////////////////////////////////
1049/// Turn on/off tracking of objects in the TObjectTable.
1050
1052{
1053 fgObjectStat = stat;
1054}
1055
1056////////////////////////////////////////////////////////////////////////////////
1057/// Return destructor only flag
1058
1060{
1061 return fgDtorOnly;
1062}
1063
1064////////////////////////////////////////////////////////////////////////////////
1065/// Set destructor only flag
1066
1068{
1069 fgDtorOnly = (Longptr_t) obj;
1070}
1071
1072////////////////////////////////////////////////////////////////////////////////
1073/// Operator delete
1074
1075void TObject::operator delete(void *ptr)
1076{
1077 if ((Longptr_t) ptr != fgDtorOnly)
1079 else
1080 fgDtorOnly = 0;
1081}
1082
1083////////////////////////////////////////////////////////////////////////////////
1084/// Operator delete []
1085
1086void TObject::operator delete[](void *ptr)
1087{
1088 if ((Longptr_t) ptr != fgDtorOnly)
1090 else
1091 fgDtorOnly = 0;
1092}
1093
1094#ifdef R__SIZEDDELETE
1095////////////////////////////////////////////////////////////////////////////////
1096/// Operator delete for sized deallocation.
1097
1098void TObject::operator delete(void *ptr, size_t size)
1099{
1100 if ((Longptr_t) ptr != fgDtorOnly)
1102 else
1103 fgDtorOnly = 0;
1104}
1105
1106////////////////////////////////////////////////////////////////////////////////
1107/// Operator delete [] for sized deallocation.
1108
1109void TObject::operator delete[](void *ptr, size_t size)
1110{
1111 if ((Longptr_t) ptr != fgDtorOnly)
1113 else
1114 fgDtorOnly = 0;
1115}
1116#endif
1117
1118////////////////////////////////////////////////////////////////////////////////
1119/// Print value overload
1120
1121std::string cling::printValue(TObject *val)
1122{
1123 std::ostringstream strm;
1124 strm << "Name: " << val->GetName() << " Title: " << val->GetTitle();
1125 return strm.str();
1126}
1127
1128#ifdef R__PLACEMENTDELETE
1129////////////////////////////////////////////////////////////////////////////////
1130/// Only called by placement new when throwing an exception.
1131
1132void TObject::operator delete(void *ptr, void *vp)
1133{
1134 TStorage::ObjectDealloc(ptr, vp);
1135}
1136
1137////////////////////////////////////////////////////////////////////////////////
1138/// Only called by placement new[] when throwing an exception.
1139
1140void TObject::operator delete[](void *ptr, void *vp)
1141{
1142 TStorage::ObjectDealloc(ptr, vp);
1143}
1144#endif
#define R__unlikely(expr)
Definition: RConfig.hxx:598
#define f(i)
Definition: RSha256.hxx:104
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition: RtypesCore.h:63
unsigned short UShort_t
Definition: RtypesCore.h:40
int Int_t
Definition: RtypesCore.h:45
long Longptr_t
Definition: RtypesCore.h:82
const Bool_t kFALSE
Definition: RtypesCore.h:101
unsigned int UInt_t
Definition: RtypesCore.h:46
float Float_t
Definition: RtypesCore.h:57
const Bool_t kTRUE
Definition: RtypesCore.h:100
unsigned long ULong_t
Definition: RtypesCore.h:55
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
#define gDirectory
Definition: TDirectory.h:348
constexpr Int_t kError
Definition: TError.h:46
void ErrorHandler(int level, const char *location, const char *fmt, std::va_list va)
General error handler function. It calls the user set error handler.
Definition: TError.cxx:112
constexpr Int_t kFatal
Definition: TError.h:49
constexpr Int_t kWarning
Definition: TError.h:45
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:188
constexpr Int_t kInfo
Definition: TError.h:44
constexpr Int_t kSysError
Definition: TError.h:48
Option_t Option_t option
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 filename
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 b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char name[80]
Definition: TGX11.cxx:110
R__EXTERN TGuiFactory * gGuiFactory
Definition: TGuiFactory.h:66
#define gInterpreter
Definition: TInterpreter.h:564
R__EXTERN TObjectTable * gObjectTable
Definition: TObjectTable.h:82
#define ATTRIBUTE_NO_SANITIZE_ADDRESS
Definition: TObject.cxx:62
Int_t gDebug
Definition: TROOT.cxx:585
#define gROOT
Definition: TROOT.h:404
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition: TString.cxx:2456
#define gPad
Definition: TVirtualPad.h:288
#define va_(arg)
Definition: Varargs.h:41
#define snprintf
Definition: civetweb.c:1540
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
virtual TProcessID * ReadProcessID(UShort_t pidf)=0
Return the current Process-ID.
Definition: TBuffer.cxx:344
virtual UShort_t WriteProcessID(TProcessID *pid)=0
Always return 0 (current processID).
Definition: TBuffer.cxx:353
virtual UShort_t GetPidOffset() const =0
Bool_t IsReading() const
Definition: TBuffer.h:86
virtual UInt_t WriteVersion(const TClass *cl, Bool_t useBcnt=kFALSE)=0
virtual void SkipVersion(const TClass *cl=nullptr)=0
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:81
void Draw(Option_t *option="") override
Draw detailed class inheritance structure.
Definition: TClass.cxx:2487
void * DynamicCast(const TClass *base, void *obj, Bool_t up=kTRUE)
Cast obj of this class type up to baseclass cl if up is true.
Definition: TClass.cxx:4904
static Int_t AutoBrowse(TObject *obj, TBrowser *browser)
Browse external object inherited from TObject.
Definition: TClass.cxx:1966
void Dump() const override
Dump contents of object on stdout.
Definition: TClass.h:396
Bool_t InheritsFrom(const char *cl) const override
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4863
virtual TInspectorImp * CreateInspectorImp(const TObject *obj, UInt_t width, UInt_t height)
Create a batch version of TInspectorImp.
Iterator of linked list.
Definition: TList.h:191
Option_t * GetOption() const override
Returns the object option stored in the list.
Definition: TList.cxx:1142
void SetOption(Option_t *option)
Sets the object option stored in the list.
Definition: TList.cxx:1151
void Add(TObject *obj) override
Definition: TList.h:81
Each ROOT class (see TClass) has a linked list of methods.
Definition: TMethod.h:38
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition: TNamed.h:48
An array of TObjects.
Definition: TObjArray.h:31
static void AddObj(TObject *obj)
Add an object to the global object table gObjectTable.
void RemoveQuietly(TObject *obj)
Remove an object from the object table.
Mother of all ROOT objects.
Definition: TObject.h:41
void AbstractMethod(const char *method) const
Use this method to implement an "abstract" method that you don't want to leave purely abstract.
Definition: TObject.cxx:1012
virtual Bool_t IsFolder() const
Returns kTRUE in case object contains browsable objects (like containers or lists of other objects).
Definition: TObject.cxx:556
virtual void Inspect() const
Dump contents of this object in a graphics canvas.
Definition: TObject.cxx:547
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Computes distance from point (px,py) to the object.
Definition: TObject.cxx:265
static void SetObjectStat(Bool_t stat)
Turn on/off tracking of objects in the TObjectTable.
Definition: TObject.cxx:1051
virtual Bool_t Notify()
This method must be overridden to handle object notification.
Definition: TObject.cxx:589
virtual Bool_t IsEqual(const TObject *obj) const
Default equal comparison (objects are equal if they have the same address in memory).
Definition: TObject.cxx:566
@ kOverwrite
overwrite existing object with same name
Definition: TObject.h:92
@ kSingleKey
write collection with single key
Definition: TObject.h:91
@ kWriteDelete
write object, then delete previous key with same name
Definition: TObject.h:93
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:440
virtual void Browse(TBrowser *b)
Browse object. May be overridden for another default action.
Definition: TObject.cxx:198
virtual void Dump() const
Dump contents of object on stdout.
Definition: TObject.cxx:349
UInt_t fUniqueID
object unique identifier
Definition: TObject.h:44
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:201
virtual const char * GetIconName() const
Returns mime type name of object.
Definition: TObject.cxx:450
virtual void RecursiveRemove(TObject *obj)
Recursively remove this object from a list.
Definition: TObject.cxx:654
virtual void DoError(int level, const char *location, const char *fmt, va_list va) const
Interface to ErrorHandler (protected).
Definition: TObject.cxx:931
virtual Bool_t HandleTimer(TTimer *timer)
Execute action in response of a timer timing out.
Definition: TObject.cxx:494
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TObject.cxx:223
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:458
@ kIsOnHeap
object is on heap
Definition: TObject.h:81
UInt_t fBits
bit field status word
Definition: TObject.h:45
static Longptr_t fgDtorOnly
object for which to call dtor only (i.e. no delete)
Definition: TObject.h:47
virtual void Streamer(TBuffer &)
Stream an object of class TObject.
Definition: TObject.cxx:883
virtual void SysError(const char *method, const char *msgfmt,...) const
Issue system error message.
Definition: TObject.cxx:984
R__ALWAYS_INLINE Bool_t IsOnHeap() const
Definition: TObject.h:152
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:207
virtual void UseCurrentStyle()
Set current style settings in this object This function is called when either TCanvas::UseCurrentStyl...
Definition: TObject.cxx:796
virtual Option_t * GetDrawOption() const
Get option used by the graphics system to draw this object.
Definition: TObject.cxx:424
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:956
void MayNotUse(const char *method) const
Use this method to signal that a method (defined in a base class) may not be called in a derived clas...
Definition: TObject.cxx:1023
virtual TObject * DrawClone(Option_t *option="") const
Draw a clone of this object in the current selected pad for instance with: gROOT->SetSelectedPad(gPad...
Definition: TObject.cxx:298
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to an event at (px,py).
Definition: TObject.cxx:394
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition: TObject.cxx:404
static TClass * Class()
virtual void Execute(const char *method, const char *params, Int_t *error=nullptr)
Execute method on this object with the given parameter string, e.g.
Definition: TObject.cxx:360
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition: TObject.cxx:184
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Returns string containing info about the object at position (px,py).
Definition: TObject.cxx:469
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
Definition: TObject.cxx:746
virtual Int_t Write(const char *name=nullptr, Int_t option=0, Int_t bufsize=0)
Write this object to the current directory.
Definition: TObject.cxx:875
@ kOnlyPrepStep
Used to request that the class specific implementation of TObject::Write just prepare the objects to ...
Definition: TObject.h:106
virtual void SaveAs(const char *filename="", Option_t *option="") const
Save this object in the file specified by filename.
Definition: TObject.cxx:681
virtual void Delete(Option_t *option="")
Delete this object.
Definition: TObject.cxx:248
static Longptr_t GetDtorOnly()
Return destructor only flag.
Definition: TObject.cxx:1059
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:775
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:526
static Bool_t GetObjectStat()
Get status of object stat flag.
Definition: TObject.cxx:1044
virtual void Copy(TObject &object) const
Copy this to obj.
Definition: TObject.cxx:140
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:970
virtual void SetDrawOption(Option_t *option="")
Set drawing option for object.
Definition: TObject.cxx:759
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:998
static void SetDtorOnly(void *obj)
Set destructor only flag.
Definition: TObject.cxx:1067
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition: TObject.cxx:786
virtual const char * GetTitle() const
Returns title of object.
Definition: TObject.cxx:484
virtual void DrawClass() const
Draw class inheritance tree of the class to which this object belongs.
Definition: TObject.cxx:289
virtual TClass * IsA() const
Definition: TObject.h:245
virtual Int_t Compare(const TObject *obj) const
Compare abstract method.
Definition: TObject.cxx:238
virtual ~TObject()
TObject destructor.
Definition: TObject.cxx:158
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition: TObject.cxx:274
virtual void Paint(Option_t *option="")
This method must be overridden if a class wants to paint itself.
Definition: TObject.cxx:602
virtual void Print(Option_t *option="") const
This method must be overridden when a class wants to print itself.
Definition: TObject.cxx:631
virtual void Pop()
Pop on object drawn in a pad to the top of the display list.
Definition: TObject.cxx:611
virtual ULong_t Hash() const
Return hash value for this object.
Definition: TObject.cxx:516
virtual void ls(Option_t *option="") const
The ls function lists the contents of a class on stdout.
Definition: TObject.cxx:575
static Bool_t fgObjectStat
if true keep track of objects in TObjectTable
Definition: TObject.h:48
void ResetBit(UInt_t f)
Definition: TObject.h:200
@ kCanDelete
if object in a list can be deleted
Definition: TObject.h:62
@ kIsReferenced
if object is referenced by a TRef or TRefArray
Definition: TObject.h:65
@ kMustCleanup
if object destructor must call RecursiveRemove()
Definition: TObject.h:64
virtual Int_t Read(const char *name)
Read contents of object with specified name from the current directory.
Definition: TObject.cxx:643
static void AddToTObjectTable(TObject *)
Private helper function which will dispatch to TObjectTable::AddObj.
Definition: TObject.cxx:175
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:944
void Obsolete(const char *method, const char *asOfVers, const char *removedFromVers) const
Use this method to declare a method obsolete.
Definition: TObject.cxx:1032
A TProcessID identifies a ROOT job in a unique way in time and space.
Definition: TProcessID.h:74
void PutObjectWithID(TObject *obj, UInt_t uid=0)
stores the object at the uid th slot in the table of objects The object uniqued is set as well as its...
Definition: TProcessID.cxx:383
static TProcessID * GetProcessWithUID(const TObject *obj)
static function returning a pointer to TProcessID with its pid encoded in the highest byte of obj->Ge...
Definition: TProcessID.cxx:297
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2828
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition: TROOT.cxx:2813
A TRefTable maintains the association between a referenced object and the parent object supporting th...
Definition: TRefTable.h:35
static TRefTable * GetRefTable()
Static function returning the current TRefTable.
Definition: TRefTable.cxx:287
virtual Int_t Add(Int_t uid, TProcessID *context=nullptr)
Add a new uid to the table.
Definition: TRefTable.cxx:88
static void ObjectDealloc(void *vp)
Used to deallocate a TObject on the heap (via TObject::operator delete()).
Definition: TStorage.cxx:363
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.
Definition: TString.cxx:671
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2323
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:51
virtual void Modified(Bool_t flag=1)=0
virtual TList * GetListOfPrimitives() const =0
virtual TVirtualPad * cd(Int_t subpadnumber=0)=0
virtual void Update()=0
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
bool DeleteChangesMemory()
Definition: TObject.cxx:127
bool DeleteChangesMemoryImpl()
Definition: TObject.cxx:76
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
void CallRecursiveRemoveIfNeeded(TObject &obj)
call RecursiveRemove for obj if gROOT is valid and obj.TestBit(kMustCleanup) is true.
Definition: TROOT.h:393