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