Go4Proxies/TGo4DabcProxy.cxx
Go to the documentation of this file.
00001 // $Id: TGo4DabcProxy.cxx 1218 2014-07-23 13:22:28Z linev $ 00002 //----------------------------------------------------------------------- 00003 // The GSI Online Offline Object Oriented (Go4) Project 00004 // Experiment Data Processing at EE department, GSI 00005 //----------------------------------------------------------------------- 00006 // Copyright (C) 2000- GSI Helmholtzzentrum für Schwerionenforschung GmbH 00007 // Planckstr. 1, 64291 Darmstadt, Germany 00008 // Contact: http://go4.gsi.de 00009 //----------------------------------------------------------------------- 00010 // This software can be used under the license agreements as stated 00011 // in Go4License.txt file which is part of the distribution. 00012 //----------------------------------------------------------------------- 00013 00014 #include "TGo4DabcProxy.h" 00015 00016 #ifndef WITHOUT_DABC 00017 00018 #include "TROOT.h" 00019 #include "TGraph.h" 00020 #include "TClass.h" 00021 #include "TAxis.h" 00022 #include "TTimer.h" 00023 #include "TBufferFile.h" 00024 #include "TMemFile.h" 00025 00026 #include "TGo4Log.h" 00027 #include "TGo4Slot.h" 00028 #include "TGo4ObjectManager.h" 00029 00030 #include "dabc/api.h" 00031 #include "dabc/version.h" 00032 #include "dabc/Hierarchy.h" 00033 #include "dabc/Manager.h" 00034 #include "dabc/Publisher.h" 00035 #include "dabc/Configuration.h" 00036 00037 extern "C" int R__unzip_header(int *nin, unsigned char *bufin, int *lout); 00038 extern "C" void R__unzip(int *nin, unsigned char* bufin, int *lout, unsigned char *bufout, int *nout); 00039 00040 bool IsRateHistory(const dabc::Hierarchy& item) 00041 { 00042 if ((item.GetField("dabc:kind").AsStr() == "rate") || 00043 (item.GetField("dabc:history").AsInt() > 0)) return kTRUE; 00044 return kFALSE; 00045 } 00046 00047 TString GetRootClassName(const dabc::Hierarchy& item) 00048 { 00049 std::string kind = item.GetField("dabc:kind").AsStr(); 00050 if (kind.find("ROOT.") == 0) { 00051 kind.erase(0,5); 00052 return kind.c_str(); 00053 } 00054 if (IsRateHistory(item)) return "TGraph"; 00055 00056 return ""; 00057 } 00058 00059 // we use fake file only to correctly reconstruct streamer infos 00060 class TFakeFile : public TMemFile { 00061 public: 00062 TList* mylist; 00063 00064 TFakeFile(TList* sinfo) : TMemFile("dummy.file", "RECREATE"), mylist(sinfo) 00065 { 00066 gROOT->GetListOfFiles()->Remove(this); 00067 } 00068 00069 virtual ~TFakeFile() {} 00070 00071 virtual TList* GetStreamerInfoList() { return (TList*) mylist->Clone(); } 00072 00073 }; 00074 00075 00076 class TGo4DabcAccess : public TGo4Access { 00077 protected: 00078 std::string fNodeName; 00079 std::string fObjName; 00080 std::string fItemName; 00081 std::string fRootClassName; 00082 std::string fMasterName; 00083 std::string fMasterItemName; 00084 bool fIsRate; 00085 int fHistoryLength; 00086 TGo4ObjectManager* fxReceiver; 00087 TString fxRecvPath; 00088 dabc::Buffer fRawData; 00089 Bool_t fCompression; 00090 00091 public: 00092 00093 TGo4DabcAccess(const std::string& node, const std::string& sinfoname) : 00094 TGo4Access(), 00095 fNodeName(node), 00096 fObjName(), 00097 fItemName(), 00098 fRootClassName(), 00099 fMasterName(), 00100 fMasterItemName(), 00101 fIsRate(false), 00102 fHistoryLength(0), 00103 fxReceiver(0), 00104 fxRecvPath(), 00105 fRawData(), 00106 fCompression(kTRUE) 00107 { 00108 fObjName = "StreamerInfo"; 00109 fItemName = sinfoname; 00110 fRootClassName = "TList"; 00111 00112 //printf("Create MASTER ACCESS %p\n", this); 00113 } 00114 00115 00116 TGo4DabcAccess(const std::string& node, const dabc::Hierarchy& item) : 00117 TGo4Access(), 00118 fNodeName(node), 00119 fObjName(), 00120 fItemName(), 00121 fRootClassName(), 00122 fMasterName(), 00123 fMasterItemName(), 00124 fIsRate(false), 00125 fHistoryLength(0), 00126 fxReceiver(0), 00127 fxRecvPath(), 00128 fRawData(), 00129 fCompression(kTRUE) 00130 { 00131 fObjName = item.GetName(); 00132 fItemName = item.ItemName(); 00133 std::string kind = item.GetField(dabc::prop_kind).AsStr(); 00134 fHistoryLength = item.GetField(dabc::prop_history).AsInt(); 00135 00136 fMasterName = item.GetField(dabc::prop_masteritem).AsStr(); 00137 fMasterItemName = item.FindMaster().ItemName(); 00138 00139 if (kind.find("ROOT.") == 0) { 00140 kind.erase(0,5); 00141 fRootClassName = kind; 00142 } else 00143 if (kind=="rate") { 00144 fIsRate = true; 00145 if (fHistoryLength > 0) fRootClassName = "TGraph"; 00146 } 00147 00148 //printf("Create ACCESS %p\n", this); 00149 } 00150 00151 virtual ~TGo4DabcAccess() 00152 { 00153 //printf("Destroy ACCESS %p\n", this); 00154 } 00155 00156 virtual Bool_t IsRemote() const { return kTRUE; } 00157 00158 virtual Bool_t CanGetObject() const { return kFALSE; } 00159 00160 virtual Bool_t GetObject(TObject* &obj, Bool_t &owner) const { return kFALSE; } 00161 00162 virtual TClass* GetObjectClass() const 00163 { 00164 if (fRootClassName.length() > 0) 00165 return (TClass*) gROOT->GetListOfClasses()->FindObject(fRootClassName.c_str()); 00166 return 0; 00167 } 00168 00169 virtual const char* GetObjectName() const 00170 { 00171 return fObjName.c_str(); 00172 } 00173 00174 virtual const char* GetObjectClassName() const 00175 { 00176 if (fRootClassName.length()>0) return fRootClassName.c_str(); 00177 00178 return "dabc::Hierarchy"; 00179 } 00180 00181 00182 virtual Int_t AssignObjectTo(TGo4ObjectManager* rcv, const char* path) 00183 { 00184 if (rcv==0) return 0; 00185 00186 dabc::WorkerRef wrk = dabc::mgr.FindItem("/Go4ReplWrk"); 00187 if (wrk.null()) return 0; 00188 00189 if (fIsRate && (fHistoryLength>0)) { 00190 dabc::CmdGetBinary cmd2; 00191 cmd2.SetStr("Item", fItemName); 00192 cmd2.SetStr("Kind","hierarchy"); 00193 cmd2.SetStr("Query", Form("history=%d",fHistoryLength)); 00194 cmd2.SetTimeout(10.); 00195 cmd2.SetReceiver(fNodeName + dabc::Publisher::DfltName()); 00196 00197 cmd2.SetPtr("#DabcAccess", this); 00198 fxReceiver = rcv; 00199 fxRecvPath = path; 00200 wrk()->Assign(cmd2); 00201 00202 if (dabc::mgr.GetCommandChannel().Submit(cmd2)) return 2; 00203 } else 00204 00205 if (!fRootClassName.empty()) { 00206 00207 TClass *cl = TClass::GetClass(fRootClassName.c_str()); 00208 if (!cl) { 00209 TGo4Log::Error("GetObject Unknown class %s", fRootClassName.c_str()); 00210 return 0; 00211 } 00212 00213 if (!cl->InheritsFrom(TObject::Class())) { 00214 // in principle user should call TKey::ReadObjectAny! 00215 TGo4Log::Error("GetObject Class %s not derived from TObject", fRootClassName.c_str()); 00216 return 0; 00217 } 00218 00219 dabc::CmdGetBinary cmd(fItemName, "root.bin", fCompression ? "zipped" : ""); 00220 // cmd.SetStr("Item", fItemName); 00221 // cmd.SetUInt("version", version); 00222 cmd.SetTimeout(10.); 00223 cmd.SetReceiver(fNodeName + dabc::Publisher::DfltName()); 00224 00225 cmd.SetPtr("#DabcAccess", this); 00226 fxReceiver = rcv; 00227 fxRecvPath = path; 00228 00229 //printf("Request for recv %p path %s master %s\n", rcv, path, fMasterName.c_str()); 00230 wrk()->Assign(cmd); 00231 00232 if (dabc::mgr.GetCommandChannel().Submit(cmd)) return 2; 00233 } 00234 00235 return 0; 00236 } 00237 00239 double ProcessCommandReply(dabc::Command cmd) 00240 { 00241 // DOUT0("ProcessCommandReply"); 00242 00243 if (cmd.GetResult() != dabc::cmd_true) { 00244 TGo4Log::Error("dabc::Command %s execution failed", cmd.GetName()); 00245 return -1; 00246 } 00247 00248 if (fRawData.null()) 00249 fRawData = cmd.GetRawData(); 00250 00251 if (fRawData.null() || (fRawData.NumSegments()==0)) { 00252 TGo4Log::Error("Did not get raw data from dabc::Command %s", cmd.GetName()); 00253 return -1; 00254 } 00255 00256 if (fIsRate && (fHistoryLength>0)) { 00257 dabc::Hierarchy res; 00258 res.Create("get"); 00259 res.SetVersion(cmd.GetUInt("version")); 00260 res.ReadFromBuffer(fRawData); 00261 00262 //DOUT0("GET:%s RES = \n%s", item.ItemName().c_str(), res.SaveToXml(dabc::xmlmask_History).c_str()); 00263 00264 dabc::HistoryIter iter = res.MakeHistoryIter(); 00265 int cnt = 0; 00266 while (iter.next()) cnt++; 00267 00268 // DOUT0("ITERATOR cnt %d", cnt); 00269 00270 if (cnt==0) return kFALSE; 00271 00272 TGraph* gr = new TGraph(cnt); 00273 gr->SetName(fObjName.c_str()); 00274 gr->SetTitle(Form("%s ratemeter", fItemName.c_str())); 00275 int i = 0; 00276 while (iter.next()) { 00277 00278 double v = iter.GetField("value").AsDouble(); 00279 uint64_t tm = iter.GetField("time").AsUInt(); 00280 00281 // DOUT0("pnt %d tm %20u value %5.2f", i, tm / 1000, v); 00282 00283 gr->SetPoint(cnt - i -1, tm / 1000, v); 00284 i++; 00285 } 00286 00287 gr->GetXaxis()->SetTimeDisplay(1); 00288 gr->GetXaxis()->SetTimeFormat("%H:%M:%S%F1970-01-01 00:00:00"); 00289 00290 DoObjectAssignement(fxReceiver, fxRecvPath.Data(), gr, kTRUE); 00291 return -1.; 00292 } 00293 00294 if (!fRootClassName.empty()) { 00295 TClass *cl = TClass::GetClass(fRootClassName.c_str()); 00296 00297 // dabc::BinDataHeader* hdr = (dabc::BinDataHeader*) fRawData.SegmentPtr(); 00298 00299 TGo4Slot* tgtslot = fxReceiver->GetSlot(fxRecvPath.Data()); 00300 00301 TGo4Slot* masterslot = 0; 00302 00303 if (!fMasterName.empty() && tgtslot && tgtslot->GetParent()) 00304 masterslot = tgtslot->GetParent()->FindSlot(fMasterName.c_str()); 00305 00306 if (masterslot) { 00307 // always request master 00308 00309 Int_t local_master_version = 0; 00310 00311 if (!masterslot->GetIntPar("dabc_version", local_master_version)) 00312 local_master_version = 0; 00313 00314 if (local_master_version >= cmd.GetInt("MVersion")) { 00315 //printf("MASTER version %d required %d EXISTS!!!\n", local_master_version, cmd.GetInt("MVersion")); 00316 } else 00317 if (masterslot->GetPar("dabc_loading")!=0) { 00318 // if master slot loading, we will try to check again 1 sec later 00319 return 1.; 00320 } else { 00321 00322 TGo4DabcAccess* maccess = new TGo4DabcAccess(fNodeName, fMasterItemName); 00323 TString tgtname = masterslot->GetFullName(); 00324 00325 //printf("Request master slot = %p tgtname %s \n", masterslot, tgtname.Data()); 00326 00327 if (maccess->AssignObjectTo(fxReceiver, tgtname.Data()) != 2) { 00328 delete maccess; 00329 TGo4Log::Error("Fail to request MASTER item %s from DABC node %s", fMasterItemName.c_str(), fNodeName.c_str()); 00330 return -1; 00331 } 00332 00333 masterslot->SetPar("dabc_loading", "true"); 00334 return 1.; // try after 1 seconds 00335 } 00336 } 00337 00338 TGo4Log::Debug("Item %s raw_data size %u master_version %u", fItemName.c_str(), fRawData.GetTotalSize(), cmd.GetInt("MVersion")); 00339 00340 char *pobj = (char*) cl->New(); 00341 00342 if (!pobj) { 00343 TGo4Log::Error("ReadObj - Cannot create new object of class %s", cl->GetName()); 00344 return true; 00345 } 00346 00347 Int_t baseOffset = cl->GetBaseClassOffset(TObject::Class()); 00348 if (baseOffset==-1) { 00349 // cl does not inherit from TObject. 00350 // Since this is not possible yet, the only reason we could reach this code 00351 // is because something is screw up in the ROOT code. 00352 TGo4Log::Error("ReadObj Incorrect detection of the inheritance from TObject for class %s.", 00353 cl->GetName()); 00354 return -1; 00355 } 00356 00357 TObject *tobj = (TObject*)(pobj+baseOffset); 00358 // Create an instance of this class 00359 00360 char* rawbuf(0); 00361 Int_t rawbuflen(0); 00362 00363 if (fCompression) { 00364 00365 int sizeinp(fRawData.GetTotalSize()), sizeout(0), irep(0); 00366 00367 if (R__unzip_header(&sizeinp, (unsigned char*) fRawData.SegmentPtr(), &sizeout)) { 00368 printf("Fail to decode zip header\n"); 00369 } else { 00370 rawbuf = (char*) malloc(sizeout); 00371 00372 R__unzip(&sizeinp, (unsigned char*) fRawData.SegmentPtr(), &sizeout, (unsigned char*) rawbuf, &irep); 00373 00374 printf("Compressed %d Uncompressed size = %d\n", sizeinp, irep); 00375 00376 rawbuflen = irep; 00377 } 00378 } else { 00379 rawbuf = (char*) fRawData.SegmentPtr(); 00380 rawbuflen = fRawData.GetTotalSize(); 00381 } 00382 00383 if (rawbuflen>0) { 00384 TBufferFile buf(TBuffer::kRead, rawbuflen, rawbuf, kFALSE); 00385 buf.MapObject(pobj,cl); 00386 tobj->Streamer(buf); 00387 } else { 00388 cl->Destructor(pobj); 00389 pobj = 0; 00390 tobj = 0; 00391 } 00392 00393 if (fCompression) free(rawbuf); 00394 00395 if ((fObjName == "StreamerInfo") && 00396 (fRootClassName == "TList") && 00397 tobj && tobj->InheritsFrom(TList::Class()) && 00398 fMasterName.empty()) { 00399 00400 TFakeFile fff((TList*) tobj); 00401 fff.ReadStreamerInfo(); 00402 00403 TGo4Log::Debug("Get streamer infos from remote"); 00404 } 00405 00406 if (tobj) { 00407 if (tgtslot) { 00408 tgtslot->RemovePar("dabc_loading"); // indicate that loading is finished 00409 tgtslot->SetIntPar("dabc_version", cmd.GetInt("BVersion")); 00410 } 00411 DoObjectAssignement(fxReceiver, fxRecvPath.Data(), tobj, kTRUE); 00412 } 00413 return -1; 00414 } 00415 00416 return -1; 00417 } 00418 00419 }; 00420 00421 00422 // =================================================================================== 00423 00424 // Timer used to invoke reply in the main process 00425 00426 class TReplyTimer : public TTimer { 00427 public: 00428 dabc::Command fCmd; 00429 00430 TReplyTimer(dabc::Command cmd) : 00431 TTimer(0), 00432 fCmd(cmd) 00433 { 00434 Add(); 00435 } 00436 00437 virtual Bool_t Notify() 00438 { 00439 double res_tm = -1.; 00440 00441 TGo4DabcAccess* acc = 0; 00442 00443 if (!fCmd.null()) { 00444 00445 acc = (TGo4DabcAccess*) fCmd.GetPtr("#DabcAccess"); 00446 TGo4DabcProxy* prox = (TGo4DabcProxy*) fCmd.GetPtr("#DabcProxy"); 00447 00448 if (acc) { 00449 res_tm = acc->ProcessCommandReply(fCmd); 00450 } else 00451 if (prox) { 00452 prox->ReplyCommand(&fCmd); 00453 fCmd.Reply(); 00454 } 00455 } 00456 00457 if (res_tm<0) { 00458 fCmd.Release(); 00459 if (acc) delete acc; 00460 Remove(); 00461 delete this; 00462 return kFALSE; 00463 } 00464 00465 Start((Long_t)res_tm*1000, kTRUE); 00466 00467 return kTRUE; 00468 } 00469 }; 00470 00471 class ReplyWorker : public dabc::Worker { 00472 protected: 00473 virtual bool ReplyCommand(dabc::Command cmd) 00474 { 00475 if ((cmd.GetPtr("#DabcAccess") != 0) || (cmd.GetPtr("#DabcProxy") != 0)) { 00476 // DOUT0("CreateReplTimer"); 00477 new TReplyTimer(cmd); 00478 return false; 00479 } 00480 00481 return dabc::Worker::ReplyCommand(cmd); 00482 } 00483 00484 public: 00485 ReplyWorker(const std::string& name) : 00486 dabc::Worker(MakePair(name)) 00487 { 00488 } 00489 00490 }; 00491 00492 00493 00494 // =================================================================================== 00495 00496 class TGo4DabcLevelIter : public TGo4LevelIter { 00497 protected: 00498 dabc::Hierarchy fParent; 00499 dabc::Hierarchy fChild; 00500 TString fClNameBuf; 00501 unsigned fCnt; 00502 00503 public: 00504 TGo4DabcLevelIter(const dabc::Hierarchy& item) : 00505 TGo4LevelIter(), 00506 fParent(item), 00507 fChild(), 00508 fCnt(0) 00509 { 00510 } 00511 00512 virtual ~TGo4DabcLevelIter() {} 00513 00514 virtual Bool_t next() 00515 { 00516 if (fParent.NumChilds()==0) return kFALSE; 00517 00518 if (fChild.null()) { 00519 fCnt = 0; 00520 fChild = fParent.GetChild(fCnt); 00521 // printf("Extract first child %s from iter\n", fChild.GetName()); 00522 } else { 00523 fCnt++; 00524 fChild.Release(); 00525 if (fCnt>=fParent.NumChilds()) return kFALSE; 00526 fChild = fParent.GetChild(fCnt); 00527 // printf("Extract %u child %s from iter\n", fCnt, fChild.GetName()); 00528 } 00529 00530 return !fChild.null(); 00531 } 00532 00533 virtual Bool_t isfolder() { return fChild.NumChilds()>0; } 00534 00535 virtual Int_t getflag(const char* flagname) 00536 { 00537 if (strcmp(flagname,"IsRemote")==0) return 1; 00538 return -1; 00539 } 00540 00541 virtual TGo4LevelIter* subiterator() 00542 { 00543 return fChild.NumChilds() > 0 ? new TGo4DabcLevelIter(fChild) : 0; 00544 } 00545 00546 virtual TGo4Slot* getslot() { return 0; } 00547 00548 virtual const char* name() { return fChild.GetName(); } 00549 virtual const char* info() { return "item from dabc"; } 00550 virtual Int_t sizeinfo() { return 0; } 00551 00552 virtual Int_t GetKind() { 00553 if (isfolder()) return TGo4Access::kndFolder; 00554 00555 if (IsRateHistory(fChild)) return TGo4Access::kndObject; 00556 00557 fClNameBuf = GetRootClassName(fChild); 00558 00559 if (fClNameBuf.Length()>0) return TGo4Access::kndObject; 00560 00561 return -1; 00562 } 00563 00564 virtual const char* GetClassName() 00565 { 00566 if (IsRateHistory(fChild)) return "TGraph"; 00567 00568 fClNameBuf = GetRootClassName(fChild); 00569 00570 if (fClNameBuf.Length()>0) return fClNameBuf.Data(); 00571 00572 return "dabc::Hierarchy"; 00573 } 00574 }; 00575 00576 00577 // ===================================================================================== 00578 00579 00580 TGo4DabcProxy::TGo4DabcProxy() : 00581 TGo4Proxy(), 00582 fNodeName(), 00583 fxHierarchy(0), 00584 fxParentSlot(0) 00585 { 00586 } 00587 00588 TGo4DabcProxy::~TGo4DabcProxy() 00589 { 00590 if (fxHierarchy!=0) { 00591 delete ((dabc::Hierarchy*) fxHierarchy); 00592 fxHierarchy = 0; 00593 } 00594 } 00595 00596 const char* TGo4DabcProxy::GetDabcVersion() 00597 { 00598 return DABC_RELEASE; 00599 } 00600 00601 Bool_t TGo4DabcProxy::Connect(const char* nodename) 00602 { 00603 if (!dabc::CreateManager("cmd", 0)) return kFALSE; 00604 00605 std::string node = dabc::MakeNodeName(nodename); 00606 00607 if (!dabc::ConnectDabcNode(node)) { 00608 fNodeName = node; 00609 return kFALSE; 00610 } 00611 00612 dabc::WorkerRef wrk = dabc::mgr.FindItem("/Go4ReplWrk"); 00613 00614 if (wrk.null()) { 00615 wrk = new ReplyWorker("/Go4ReplWrk"); 00616 wrk()->AssignToThread(dabc::mgr.thread()); 00617 } 00618 00619 // printf("Connection to %s done\n", nodename); 00620 00621 fNodeName = node; 00622 00623 return UpdateHierarchy(kTRUE); 00624 } 00625 00626 Bool_t TGo4DabcProxy::ReplyCommand(void* _cmd) 00627 { 00628 dabc::Command cmd = *((dabc::Command*)_cmd); 00629 00630 if (cmd.IsName(dabc::CmdGetNamesList::CmdName())) { 00631 00632 dabc::Buffer buf = cmd.GetRawData(); 00633 00634 if (buf.null()) return kFALSE; 00635 00636 if (fxHierarchy==0) { 00637 fxHierarchy = new dabc::Hierarchy(); 00638 } 00639 00640 dabc::Hierarchy& hierarchy = *((dabc::Hierarchy*) fxHierarchy); 00641 hierarchy.Release(); 00642 00643 // DOUT0("Get raw data %p %u", buf.SegmentPtr(), buf.GetTotalSize()); 00644 if (!hierarchy.ReadFromBuffer(buf)) return kFALSE; 00645 00646 if (fxParentSlot!=0) 00647 fxParentSlot->ForwardEvent(fxParentSlot, TGo4Slot::evObjUpdated); 00648 } 00649 00650 //printf("Read from DABC node %s done\n", fNodeName.Data()); 00651 return kTRUE; 00652 } 00653 00654 00655 Bool_t TGo4DabcProxy::UpdateHierarchy(Bool_t sync) 00656 { 00657 if (fNodeName.Length() == 0) return kFALSE; 00658 00659 dabc::CmdGetNamesList cmd2; 00660 cmd2.SetReceiver(std::string(fNodeName.Data()) + dabc::Publisher::DfltName()); 00661 cmd2.SetTimeout(10.); 00662 00663 dabc::WorkerRef wrk = dabc::mgr.FindItem("/Go4ReplWrk"); 00664 00665 if (!sync && !wrk.null()) { 00666 cmd2.SetPtr("#DabcProxy", this); 00667 wrk()->Assign(cmd2); 00668 00669 dabc::mgr.GetCommandChannel().Submit(cmd2); 00670 return kTRUE; 00671 } 00672 00673 if (dabc::mgr.GetCommandChannel().Execute(cmd2)!=dabc::cmd_true) { 00674 TGo4Log::Error("Fail to get remote hierarchy"); 00675 return kFALSE; 00676 } 00677 00678 return ReplyCommand(&cmd2); 00679 } 00680 00681 void TGo4DabcProxy::Initialize(TGo4Slot* slot) 00682 { 00683 fxParentSlot = slot; 00684 } 00685 00686 void TGo4DabcProxy::Finalize(TGo4Slot* slot) 00687 { 00688 } 00689 00690 Bool_t TGo4DabcProxy::HasSublevels() const 00691 { 00692 if (fxHierarchy == 0) return false; 00693 00694 dabc::Hierarchy& hierarchy = *((dabc::Hierarchy*) fxHierarchy); 00695 00696 return hierarchy.NumChilds() > 0; 00697 } 00698 00699 TGo4Access* TGo4DabcProxy::MakeProxy(const char* name) 00700 { 00701 //printf("Make PROXY\n"); 00702 00703 if (fxHierarchy == 0) return 0; 00704 00705 dabc::Hierarchy& hierarchy = *((dabc::Hierarchy*) fxHierarchy); 00706 00707 if (hierarchy.null()) return 0; 00708 00709 if ((name==0) || (strlen(name)==0)) { 00710 //printf("Create access to current item %s\n", hierarchy.GetName()); 00711 return new TGo4DabcAccess(fNodeName.Data(), hierarchy); 00712 } 00713 00714 dabc::Hierarchy child = hierarchy.FindChild(name); 00715 00716 // DOUT0("CreateREQ %s", name); 00717 00718 return child.null() ? 0 : new TGo4DabcAccess(fNodeName.Data(), child); 00719 } 00720 00721 TGo4LevelIter* TGo4DabcProxy::MakeIter() 00722 { 00723 if (fxHierarchy == 0) return 0; 00724 00725 dabc::Hierarchy& hierarchy = *((dabc::Hierarchy*) fxHierarchy); 00726 00727 // printf("TGo4DabcProxy::MakeIter()\n"); 00728 00729 return hierarchy.null() ? 0 : new TGo4DabcLevelIter(hierarchy); 00730 } 00731 00732 void TGo4DabcProxy::WriteData(TGo4Slot* slot, TDirectory* dir, Bool_t onlyobjs) 00733 { 00734 } 00735 00736 void TGo4DabcProxy::ReadData(TGo4Slot* slot, TDirectory* dir) 00737 { 00738 } 00739 00740 void TGo4DabcProxy::Update(TGo4Slot* slot, Bool_t strong) 00741 { 00742 if (strong) { 00743 printf("GO4 WANTS update DABC hierarchy - do it\n"); 00744 UpdateHierarchy(kFALSE); 00745 } 00746 } 00747 00748 void TGo4DabcProxy::RefreshNamesList() 00749 { 00750 UpdateHierarchy(kFALSE); 00751 } 00752 00753 00754 #else 00755 00756 TGo4DabcProxy::TGo4DabcProxy() : 00757 TGo4Proxy(), 00758 fNodeName(), 00759 fxHierarchy(0), 00760 fxParentSlot(0) 00761 { 00762 } 00763 00764 TGo4DabcProxy::~TGo4DabcProxy() 00765 { 00766 } 00767 00768 const char* TGo4DabcProxy::GetDabcVersion() 00769 { 00770 return 0; 00771 } 00772 00773 Bool_t TGo4DabcProxy::Connect(const char* nodename) 00774 { 00775 return kFALSE; 00776 } 00777 00778 Bool_t TGo4DabcProxy::UpdateHierarchy(Bool_t sync) 00779 { 00780 return kFALSE; 00781 } 00782 00783 Bool_t TGo4DabcProxy::ReplyCommand(void* cmd) 00784 { 00785 return kFALSE; 00786 } 00787 00788 00789 void TGo4DabcProxy::Initialize(TGo4Slot* slot) 00790 { 00791 } 00792 00793 void TGo4DabcProxy::Finalize(TGo4Slot* slot) 00794 { 00795 } 00796 00797 Bool_t TGo4DabcProxy::HasSublevels() const 00798 { 00799 return kFALSE; 00800 } 00801 00802 TGo4Access* TGo4DabcProxy::MakeProxy(const char* name) 00803 { 00804 return 0; 00805 } 00806 00807 TGo4LevelIter* TGo4DabcProxy::MakeIter() 00808 { 00809 return 0; 00810 } 00811 00812 void TGo4DabcProxy::WriteData(TGo4Slot* slot, TDirectory* dir, Bool_t onlyobjs) 00813 { 00814 00815 } 00816 00817 void TGo4DabcProxy::ReadData(TGo4Slot* slot, TDirectory* dir) 00818 { 00819 00820 } 00821 00822 void TGo4DabcProxy::Update(TGo4Slot* slot, Bool_t strong) 00823 { 00824 } 00825 00826 void TGo4DabcProxy::RefreshNamesList() 00827 { 00828 } 00829 00830 00831 #endif
