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