GSI Object Oriented Online Offline (Go4) GO4-6.4.0
Loading...
Searching...
No Matches
TGo4Slot.cxx
Go to the documentation of this file.
1// $Id$
2//-----------------------------------------------------------------------
3// The GSI Online Offline Object Oriented (Go4) Project
4// Experiment Data Processing at EE department, GSI
5//-----------------------------------------------------------------------
6// Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
7// Planckstr. 1, 64291 Darmstadt, Germany
8// Contact: http://go4.gsi.de
9//-----------------------------------------------------------------------
10// This software can be used under the license agreements as stated
11// in Go4License.txt file which is part of the distribution.
12//-----------------------------------------------------------------------
13
14#include "TGo4Slot.h"
15
16#include "TROOT.h"
17#include "TClass.h"
18
19#include "TGo4Iter.h"
20#include "TGo4ObjectProxy.h"
21
23 public:
24 TGo4SlotIter() : TGo4LevelIter(), fSlot(nullptr), fIndex(-1) {}
25
26 TGo4SlotIter(const TGo4Slot *slot) : TGo4LevelIter(), fSlot(slot), fIndex(-1) {}
27
28 virtual ~TGo4SlotIter() {}
29
30 Bool_t next() override
31 { return fSlot && (++fIndex<fSlot->NumChilds()); }
32
33 Bool_t isfolder() override { return curSlot()->HasSubLevels(); }
34
35 Bool_t isslotsfolder() override { return curSlot()->HasSlotsSubLevels(); }
36
37 TGo4LevelIter *subiterator() override { return curSlot()->MakeLevelIter(); }
38
39 TGo4Slot *getslot() override { return curSlot(); }
40
41 const char *name() override { return curSlot()->GetName(); }
42
43 const char *info() override { return curSlot()->GetInfo(); }
44
45 Int_t sizeinfo() override { return curSlot()->GetSizeInfo(); }
46
47 Int_t GetKind() override { return curSlot()->GetSlotKind(); }
48
49 const char *GetClassName() override { return curSlot()->GetSlotClassName(); }
50
51 protected:
52 TGo4Slot *curSlot() const { return fSlot->GetChild(fIndex); }
53
54 const TGo4Slot *fSlot{nullptr};
55 Int_t fIndex{-1};
56};
57
58// **********************************************************************************
59
60
62 TNamed()
63{
64 SetBit(kStartDelete, kFALSE);
65}
66
68 TNamed(),
69 fParent(parent)
70{
71 SetBit(kStartDelete, kFALSE);
72
73 if (parent)
74 parent->AddChild(this);
75
76 Event(this, evCreate);
77}
78
79TGo4Slot::TGo4Slot(TGo4Slot *parent, const char *name, const char *title) :
80 TNamed(name, title),
81 fParent(parent)
82{
83 SetBit(kStartDelete, kFALSE);
84
85 if (parent)
86 parent->AddChild(this);
87
88 Event(this, evCreate);
89}
90
92{
93 // sequence of calls here is very important
94 // First, we emit message from slot itself to inform all dependent slots
95 // that we intend to delete our objects. After that all dependent slots
96 // are informed and we can remove object (with clean proxy), delete childs
97 // and remove parameters
98
99 if (gDebug>1) Info("~TGo4Slot","%p Starting name = %s", this, GetFullName().Data());
100
101 SetBit(kStartDelete, kTRUE);
102
103 if (gDebug>1) Info("~TGo4Slot","%p CleanProxy()", this);
104 CleanProxy();
105
106 if (gDebug>1) Info("~TGo4Slot","%p Event(this, evDelete)", this);
107 Event(this, evDelete);
108
109 if (gDebug>1) Info("~TGo4Slot","%p DeleteChilds()", this);
110 DeleteChilds();
111
112 if (gDebug>1) Info("~TGo4Slot","%p Detach from parent", this);
113 if (fParent) {
114 fParent->RemoveChild(this);
115 fParent = nullptr;
116 }
117
118 if (gDebug>1) Info("~TGo4Slot","%p fPars.Delete()", this);
119 fPars.Delete();
120
121 if (fChilds) {
122 if (gDebug>1) Info("~TGo4Slot","%p Detach rest children", this);
123 for (Int_t n = 0; n <= fChilds->GetLast(); n++) {
124 TGo4Slot *child = (TGo4Slot *) fChilds->At(n);
125 if (!child) continue;
126 child->fParent = nullptr;
127 fChilds->Remove(child);
128 }
129
130 delete fChilds;
131 fChilds = nullptr;
132 }
133
134 if (gDebug>1) Info("~TGo4Slot","%p Finish", this);
135
136
137// *********************************************************************
138// This is new sequence, but also has a problems
139// SetBit(kStartDelete, kTRUE);
140
141// Info("~TGo4Slot","DeleteChilds() %x", this);
142// DeleteChilds();
143
144// Info("~TGo4Slot","Event(this, evDelete) %x %s", this, GetFullName().Data());
145// Event(this, evDelete);
146
147// Info("~TGo4Slot","CleanProxy() %x", this);
148// CleanProxy();
149
150// Info("~TGo4Slot","Dettach from parent %x", this);
151// if (fParent) {
152// fParent->RemoveChild(this);
153// fParent = nullptr;
154// }
155
156// Info("~TGo4Slot","fPars.Delete() %x", this);
157// fPars.Delete();
158
159
160
161
162// *********************************************************************
163// This is old sequence. CleanProxy() breaks all dependency and delete objects first
164// before message can be distributed over dependent slots
165// CleanProxy();
166// DeleteChilds();
167// Event(this, evDelete);
168// fPars.Delete();
169}
170
171void TGo4Slot::Delete(Option_t *)
172{
173 if (DoingDelete()) return;
174
175 delete this;
176}
177
178Bool_t TGo4Slot::IsParent(const TGo4Slot *slot) const
179{
180 TGo4Slot *parent = GetParent();
181 while (parent) {
182 if (parent==slot) return kTRUE;
183 parent = parent->GetParent();
184 }
185 return kFALSE;
186}
187
188void TGo4Slot::DeleteChild(const char *name)
189{
190 TGo4Slot *child = FindChild(name);
191 if (!child) return;
192
193 if (!child->DoingDelete())
194 delete child;
195
196 if ((NumChilds() == 0) && fChilds) {
197 delete fChilds;
198 fChilds = nullptr;
199 }
200}
201
202void TGo4Slot::DeleteChilds(const char *startedwith)
203{
204 UInt_t len = !startedwith ? 0 : strlen(startedwith);
205
206 for (Int_t n = NumChilds() - 1; n >= 0; n--) {
207 TGo4Slot *child = GetChild(n);
208 if (!child) continue;
209
210 Bool_t flag = (len == 0) ||
211 ((len<strlen(child->GetName())) &&
212 (strncmp(child->GetName(), startedwith, len) == 0));
213
214 if (!flag) continue;
215
216 if (!child->DoingDelete())
217 delete child;
218 }
219
220 if (fChilds && (NumChilds() == 0)) {
221 delete fChilds;
222 fChilds = nullptr;
223 }
224}
225
226Int_t TGo4Slot::GetIndexOf(const TGo4Slot *child) const
227{
228 if (!child) return -1;
229 for (int n = 0; n < NumChilds(); n++)
230 if (GetChild(n) == child)
231 return n;
232 return -1;
233}
234
235
237{
238 if (!child) return nullptr;
239 for (int n = 0; n < NumChilds() - 1; n++)
240 if (GetChild(n) == child)
241 return GetChild(n + 1);
242 return nullptr;
243}
244
245TGo4Slot *TGo4Slot::FindChild(const char *name) const
246{
247 if (!name || !*name) return nullptr;
248 Int_t num = NumChilds();
249 for (Int_t n = 0; n < num; n++) {
250 TGo4Slot *slot = GetChild(n);
251 if (strcmp(slot->GetName(), name) == 0)
252 return slot;
253 }
254 return nullptr;
255}
256
257
259{
260 TGo4Slot *parent = GetParent();
261 return !parent ? nullptr : parent->GetNextChild(this);
262}
263
264void TGo4Slot::ProduceFullName(TString &name, TGo4Slot *toparent)
265{
266 if (GetParent() && (GetParent() != toparent)) {
267 GetParent()->ProduceFullName(name, toparent);
268 if (name.Length() > 0) name += "/";
269 name += GetName();
270 } else
271 name = GetName();
272}
273
275{
276 TString res;
277 ProduceFullName(res, toparent);
278 return res;
279}
280
281
283{
284 return GetParent() ? GetParent()->GetOM() : nullptr;
285}
286
288{
289 if (fProxy) {
290 fProxy->Finalize(this);
291 delete fProxy;
292 fProxy = nullptr;
293 }
294}
295
297{
298 CleanProxy();
299
300 fProxy = cont;
301
302 const char *contclass = fProxy ? fProxy->ClassName() : nullptr;
303
304 SetPar("::ProxyClass", contclass);
305
306 if (fProxy) {
307 fProxy->Initialize(this);
308 Event(this, evContAssigned);
309 }
310}
311
312const char *TGo4Slot::GetInfo()
313{
314 const char *info = nullptr;
315 if (fProxy)
316 info = fProxy->GetContainedObjectInfo();
317 if (!info) info = GetTitle();
318 return info;
319}
320
322{
323 Int_t sz = -1;
324 if (fProxy)
325 sz = fProxy->GetObjectSizeInfo();
326 return sz;
327}
328
330{
331 return fProxy ? fProxy->GetObjectKind() : TGo4Access::kndFolder;
332}
333
334const char *TGo4Slot::GetSlotClassName() const
335{
336 return fProxy ? fProxy->GetContainedClassName() : nullptr;
337}
338
339Bool_t TGo4Slot::IsAcceptObject(TClass *cl) const
340{
341 return fProxy ? fProxy->IsAcceptObject(cl) : kFALSE;
342}
343
344Bool_t TGo4Slot::AssignObject(TObject *obj, Bool_t owner)
345{
346 fAssignCnt++;
347 fAssignFlag = kFALSE;
348 if (fProxy)
349 fAssignFlag = fProxy->AssignObject(this, obj, owner);
350 else if (owner)
351 delete obj;
352
353 return fAssignFlag == (Int_t) kTRUE;
354}
355
357{
358 return fProxy ? fProxy->GetAssignedObject() : nullptr;
359}
360
361void TGo4Slot::Update(Bool_t strong)
362{
363 if (fProxy)
364 fProxy->Update(this, strong);
365
366 for (int n = 0; n < NumChilds(); n++)
367 GetChild(n)->Update(strong);
368}
369
371{
372 if (fProxy && fProxy->Use()) return fProxy->HasSublevels();
373
374 return HasSlotsSubLevels();
375}
376
378{
379 return NumChilds() > 0;
380}
381
383{
384 TGo4LevelIter *res = nullptr;
385
386 if (fProxy && fProxy->Use())
387 res = fProxy->MakeIter();
388
389 if (!res && (NumChilds() > 0))
390 res = new TGo4SlotIter(this);
391
392 return res;
393}
394
395std::unique_ptr<TGo4Access> TGo4Slot::ProvideSlotAccess(const char *name)
396{
397 if (fProxy && fProxy->Use())
398 return fProxy->ProvideAccess(name);
399
400 if (!name || !*name)
401 return std::make_unique<TGo4ObjectAccess>(this);
402
403 const char *subname = nullptr;
404
405 TGo4Slot *subslot = DefineSubSlot(name, subname);
406
407 return !subslot ? nullptr : subslot->ProvideSlotAccess(subname);
408}
409
410void TGo4Slot::SaveData(TDirectory *dir, Bool_t onlyobjs)
411{
412 if (fProxy)
413 fProxy->WriteData(this, dir, onlyobjs);
414}
415
416void TGo4Slot::ReadData(TDirectory *dir)
417{
418 CleanProxy();
419
420 const char *contclass = GetPar("::ProxyClass");
421 TClass *cl = !contclass ? nullptr : gROOT->GetClass(contclass);
422 if (!cl) return;
423
424 TGo4Proxy* cont = (TGo4Proxy*) cl->New();
425
426 cont->ReadData(this, dir);
427
428 SetProxy(cont);
429}
430
431TGo4Slot *TGo4Slot::DefineSubSlot(const char *name, const char *&subname) const
432{
433 Int_t len = 0;
434
435 const char *spos = strchr(name,'/');
436
437 if (!spos) { len = strlen(name); subname = nullptr; }
438 else { len = spos-name; subname = spos+1; }
439 UInt_t ulen = (UInt_t) len;
440
441 Int_t num = NumChilds();
442 for (int n = 0; n < num; n++) {
443 TGo4Slot *slot = GetChild(n);
444 const char *slotname = slot->GetName();
445 if ((strlen(slotname)==ulen) && (strncmp(slotname, name, len) == 0)) return slot;
446 }
447
448 return nullptr;
449}
450
451TGo4Slot *TGo4Slot::GetSlot(const char *name, Bool_t force)
452{
453 if (!name || !*name) return this;
454
455 const char *subname = nullptr;
456
457 TGo4Slot *subslot = DefineSubSlot(name, subname);
458
459 if (!subslot && force) {
460 TString newname;
461 if (!subname) newname = name;
462 else newname.Append(name, subname-name-1);
463 subslot = new TGo4Slot(this, newname.Data(), "folder");
464 }
465
466 return !subslot ? nullptr : subslot->GetSlot(subname, force);
467}
468
469TGo4Slot *TGo4Slot::FindSlot(const char *fullpath, const char **subname)
470{
471 // exclude current dir and process parent dir
472 while (fullpath && (strlen(fullpath) > 2)) {
473 // ignore current dir
474 if (strncmp(fullpath, "./", 2) == 0) { fullpath += 2; continue; }
475 // process parent dir
476
477 if ((strncmp(fullpath, "../", 3) == 0) && GetParent())
478 return GetParent()->FindSlot(fullpath + 3, subname);
479
480 break;
481 }
482
483 TGo4Slot *slot = GetSlot(fullpath);
484 if (slot) {
485 if (subname) *subname = nullptr;
486 return slot;
487 }
488
489 const char *curname = fullpath;
490 TGo4Slot *curslot = this;
491
492 while (curslot) {
493 const char *nextname = nullptr;
494 TGo4Slot *nextslot = curslot->DefineSubSlot(curname, nextname);
495 if (!nextslot) break;
496 curslot = nextslot;
497 curname = nextname;
498 }
499
500 if (subname) *subname = curname;
501 return curslot;
502}
503
504
506{
507 if (!fChilds) return kFALSE;
508 Int_t indx1 = !before ? -1 : fChilds->IndexOf(before);
509 Int_t indx2 = !slot ? -1 : fChilds->IndexOf(slot);
510 if ((indx1 < 0) || (indx2 < 0) || (indx1 > indx2)) return kFALSE;
511 if (indx1 == indx2) return kTRUE;
512
513 for (int n = indx2; n > indx1; n--)
514 (*fChilds)[n] = (*fChilds)[n - 1];
515
516 (*fChilds)[indx1] = slot;
517
518 return kTRUE;
519}
520
522{
523 if (!fChilds) return kFALSE;
524 Int_t indx1 = !slot ? -1 : fChilds->IndexOf(slot);
525 Int_t indx2 = !after ? -1 : fChilds->IndexOf(after);
526 if ((indx1<0) || (indx2<0) || (indx1>indx2)) return kFALSE;
527
528 if (indx1==indx2) return kTRUE;
529
530 for (int n=indx1;n<indx2;n++)
531 (*fChilds)[n] = (*fChilds)[n+1];
532 (*fChilds)[indx2] = slot;
533
534 return kTRUE;
535}
536
538{
539 if (!child) return;
540 if (!fChilds) fChilds = new TObjArray;
541 fChilds->Add(child);
542}
543
545{
546 if (!child || !fChilds) return;
547 fChilds->Remove(child);
548 fChilds->Compress();
549 if (fChilds->GetLast()<0) {
550 delete fChilds;
551 fChilds = nullptr;
552 }
553}
554
555void TGo4Slot::Event(TGo4Slot *source, Int_t id, void *param)
556{
557 Bool_t doforward = kTRUE;
558
559 if (fProxy)
560 doforward = fProxy->ProcessEvent(this, source, id, param);
561
562 if (doforward) ForwardEvent(source, id, param);
563}
564
565void TGo4Slot::ForwardEvent(TGo4Slot *source, Int_t id, void *param)
566{
567 if (GetParent())
568 GetParent()->Event(source, id, param);
569}
570
572{
573 if (fProxy)
574 if (fProxy->RemoveRegisteredObject(obj))
575 delete this;
576}
577
578void TGo4Slot::Print(Option_t *option) const
579{
580 TGo4Iter iter((TGo4Slot *)this);
581 while (iter.next()) {
582 printf("%*c%s%s - %s\n", (iter.level()+1)*2, ' ', iter.getname(), (iter.isfolder() ? "/" : ""), iter.getinfo());
583 }
584}
585
586void TGo4Slot::SetPar(const char *name, const char *value)
587{
588 if (!name || !*name) return;
589 if (!value) { RemovePar(name); return; }
590
591 TNamed *par = (TNamed*) fPars.FindObject(name);
592 if (par)
593 par->SetTitle(value);
594 else
595 fPars.Add(new TNamed(name,value));
596}
597
598const char *TGo4Slot::GetPar(const char *name) const
599{
600 if (!name || !*name)
601 return nullptr;
602 TNamed *par = (TNamed*) fPars.FindObject(name);
603 return par ? par->GetTitle() : nullptr;
604}
605
606void TGo4Slot::RemovePar(const char *name)
607{
608 if (!name || !*name) return;
609 TNamed *par = (TNamed*) fPars.FindObject(name);
610 if (par) {
611 fPars.Remove(par);
612 fPars.Compress();
613 delete par;
614 }
615}
616
617void TGo4Slot::SetIntPar(const char *name, Int_t value)
618{
619 TString buf;
620 buf.Form("%d",value);
621 SetPar(name, buf.Data());
622}
623
624Bool_t TGo4Slot::GetIntPar(const char *name, Int_t &value) const
625{
626 const char *strvalue = GetPar(name);
627 if (!strvalue) return kFALSE;
628 value = atoi(strvalue);
629 return kTRUE;
630}
631
632void TGo4Slot::PrintPars(Int_t level)
633{
634 for (int n = 0; n <= fPars.GetLast(); n++) {
635 TNamed *par = (TNamed*) fPars.At(n);
636 if (par)
637 printf("%*c%s = %s\n", level, ' ', par->GetName(), par->GetTitle());
638 }
639}
640
641const char *TGo4Slot::FindFolderSeparator(const char *name)
642{
643 return !name ? nullptr : strrchr(name,'/');
644}
645
646void TGo4Slot::ProduceFolderAndName(const char *fullname, TString &foldername, TString &objectname)
647{
648 const char *rslash = FindFolderSeparator(fullname);
649 foldername = "";
650
651 if (!rslash) {
652 objectname = fullname;
653 } else {
654 foldername.Append(fullname, rslash-fullname);
655 objectname = (rslash+1);
656 }
657}
Bool_t isfolder()
Definition TGo4Iter.cxx:109
const char * getinfo()
Definition TGo4Iter.cxx:121
Bool_t next(Bool_t goesinto=kTRUE)
Definition TGo4Iter.cxx:44
Int_t level() const
Definition TGo4Iter.cxx:156
const char * getname()
Definition TGo4Iter.cxx:115
virtual void ReadData(TGo4Slot *, TDirectory *)
Definition TGo4Proxy.h:120
TGo4Slot * curSlot() const
Definition TGo4Slot.cxx:52
virtual ~TGo4SlotIter()
Definition TGo4Slot.cxx:28
const char * GetClassName() override
Definition TGo4Slot.cxx:49
const char * name() override
Definition TGo4Slot.cxx:41
Bool_t isfolder() override
Definition TGo4Slot.cxx:33
Bool_t next() override
Definition TGo4Slot.cxx:30
const TGo4Slot * fSlot
Definition TGo4Slot.cxx:54
const char * info() override
Definition TGo4Slot.cxx:43
TGo4Slot * getslot() override
Definition TGo4Slot.cxx:39
TGo4SlotIter(const TGo4Slot *slot)
Definition TGo4Slot.cxx:26
Int_t sizeinfo() override
Definition TGo4Slot.cxx:45
Bool_t isslotsfolder() override
Definition TGo4Slot.cxx:35
TGo4LevelIter * subiterator() override
Definition TGo4Slot.cxx:37
Int_t GetKind() override
Definition TGo4Slot.cxx:47
TGo4Slot * GetParent() const
Definition TGo4Slot.h:58
TGo4Slot * DefineSubSlot(const char *name, const char *&subname) const
Definition TGo4Slot.cxx:431
TString GetFullName(TGo4Slot *toparent=nullptr)
Definition TGo4Slot.cxx:274
virtual TGo4ObjectManager * GetOM() const
Definition TGo4Slot.cxx:282
virtual void Update(Bool_t strong=kFALSE)
Definition TGo4Slot.cxx:361
Bool_t GetIntPar(const char *name, Int_t &value) const
Definition TGo4Slot.cxx:624
TGo4Slot * FindSlot(const char *fullpath, const char **subname=nullptr)
Definition TGo4Slot.cxx:469
Bool_t IsParent(const TGo4Slot *slot) const
Definition TGo4Slot.cxx:178
const char * GetSlotClassName() const
Definition TGo4Slot.cxx:334
Int_t fAssignCnt
! counts number of object assignment
Definition TGo4Slot.h:42
void RemoveChild(TGo4Slot *child)
Definition TGo4Slot.cxx:544
Int_t fAssignFlag
! use in object manager to poll until object is assigned
Definition TGo4Slot.h:41
void AddChild(TGo4Slot *child)
Definition TGo4Slot.cxx:537
Bool_t DoingDelete() const
Definition TGo4Slot.h:125
Int_t GetSlotKind() const
Definition TGo4Slot.cxx:329
void SetProxy(TGo4Proxy *cont)
Definition TGo4Slot.cxx:296
TObjArray * fChilds
Definition TGo4Slot.h:38
TGo4Slot * GetSlot(const char *name, Bool_t force=kFALSE)
Definition TGo4Slot.cxx:451
TGo4Proxy * fProxy
!
Definition TGo4Slot.h:40
@ evContAssigned
Definition TGo4Slot.h:48
@ evDelete
Definition TGo4Slot.h:45
@ evCreate
Definition TGo4Slot.h:46
virtual ~TGo4Slot()
Definition TGo4Slot.cxx:91
Int_t NumChilds() const
Definition TGo4Slot.h:76
void SaveData(TDirectory *dir, Bool_t onlyobjs=kFALSE)
Definition TGo4Slot.cxx:410
TGo4Slot * FindChild(const char *name) const
Definition TGo4Slot.cxx:245
Int_t GetSizeInfo()
Definition TGo4Slot.cxx:321
TGo4Slot * GetNextChild(const TGo4Slot *child) const
Definition TGo4Slot.cxx:236
@ kStartDelete
Definition TGo4Slot.h:29
void ForwardEvent(TGo4Slot *source, Int_t id, void *param=nullptr)
Definition TGo4Slot.cxx:565
void RecursiveRemove(TObject *obj) override
Definition TGo4Slot.cxx:571
void CleanProxy()
Definition TGo4Slot.cxx:287
std::unique_ptr< TGo4Access > ProvideSlotAccess(const char *name)
Definition TGo4Slot.cxx:395
static void ProduceFolderAndName(const char *fullname, TString &foldername, TString &objectname)
Definition TGo4Slot.cxx:646
static const char * FindFolderSeparator(const char *name)
Definition TGo4Slot.cxx:641
virtual void ProduceFullName(TString &name, TGo4Slot *toparent=nullptr)
Definition TGo4Slot.cxx:264
Bool_t AssignObject(TObject *obj, Bool_t owner)
Definition TGo4Slot.cxx:344
Bool_t ShiftSlotBefore(TGo4Slot *slot, TGo4Slot *before)
Definition TGo4Slot.cxx:505
void DeleteChilds(const char *startedwith=nullptr)
Definition TGo4Slot.cxx:202
TGo4Slot * fParent
Definition TGo4Slot.h:37
void SetPar(const char *name, const char *value)
Definition TGo4Slot.cxx:586
void RemovePar(const char *name)
Definition TGo4Slot.cxx:606
void SetIntPar(const char *name, Int_t value)
Definition TGo4Slot.cxx:617
const char * GetInfo()
Definition TGo4Slot.cxx:312
TObject * GetAssignedObject()
Definition TGo4Slot.cxx:356
const char * GetPar(const char *name) const
Definition TGo4Slot.cxx:598
TGo4LevelIter * MakeLevelIter() const
Definition TGo4Slot.cxx:382
void PrintPars(Int_t level=3)
Definition TGo4Slot.cxx:632
Bool_t HasSlotsSubLevels() const
Definition TGo4Slot.cxx:377
void ReadData(TDirectory *dir)
Definition TGo4Slot.cxx:416
Bool_t ShiftSlotAfter(TGo4Slot *slot, TGo4Slot *after)
Definition TGo4Slot.cxx:521
void Delete(Option_t *opt="") override
Definition TGo4Slot.cxx:171
TGo4Slot * GetChild(Int_t n) const
Definition TGo4Slot.h:77
virtual void Event(TGo4Slot *source, Int_t id, void *param=nullptr)
Definition TGo4Slot.cxx:555
void DeleteChild(const char *name)
Definition TGo4Slot.cxx:188
Bool_t HasSubLevels() const
Definition TGo4Slot.cxx:370
TObjArray fPars
Definition TGo4Slot.h:39
Bool_t IsAcceptObject(TClass *cl) const
Definition TGo4Slot.cxx:339
TGo4Slot * GetNext() const
Definition TGo4Slot.cxx:258
void Print(Option_t *opt="") const override
Definition TGo4Slot.cxx:578
Int_t GetIndexOf(const TGo4Slot *child) const
Definition TGo4Slot.cxx:226