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