GSI Object Oriented Online Offline (Go4)  GO4-6.2.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
TGo4ThreadHandler.cxx
Go to the documentation of this file.
1 // $Id: TGo4ThreadHandler.cxx 2758 2020-04-16 12:28:24Z 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 "TGo4ThreadHandler.h"
15 
16 #include "TGo4Thread.h"
17 #include "TObjArray.h"
18 #include "TMutex.h"
19 
20 #include "TGo4Log.h"
21 #include "TGo4LockGuard.h"
22 #include "TGo4ThreadManager.h"
23 
25  : TNamed(right)
26 {
27  GO4TRACE((15,"TGo4ThreadHandler::TGo4ThreadHandler() copy constructor",__LINE__, __FILE__));
28  fxManager = right.fxManager;
29  fxListMutex=new TMutex;
30  fxOperMutex=new TMutex;
31  fxArray= (TObjArray*) ((right.fxArray)->Clone());
32  fxIterator=fxArray->MakeIterator();
33 }
34 
36  :TNamed(name,"This is a TGo4ThreadHandler"),fbIsOperating(kFALSE)
37 {
38  GO4TRACE((15,"TGo4ThreadHandler::TGo4ThreadHandler(const char*, TGo4ThreadManager*) constructor",__LINE__, __FILE__));
39  fxManager=parent;
40  fxListMutex=new TMutex;
41  fxOperMutex=new TMutex;
42  fxArray=new TObjArray;
43  fxIterator=fxArray->MakeIterator();
44 }
45 
46 
48 {
49  GO4TRACE((15,"TGo4ThreadHandler::~TGo4ThreadHandler() destructor",__LINE__, __FILE__));
50  StopAll();
51  CancelAll();
52  TGo4Thread* th=0;
53  {
54  TGo4LockGuard listguard(fxListMutex);
55  fxIterator->Reset();
56  while((th= (TGo4Thread*) fxIterator->Next())!=0)
57  {
58  if(th->IsInternal())
59  // internal mode? then delete thread object
60  {
61  GO4TRACE((14,"TGo4ThreadHandler::~TGo4ThreadHandler() Removing internal mode thread",__LINE__, __FILE__));
62  fxArray->Remove(th);
63  fxArray->Compress();
64  fxArray->Expand(fxArray->GetLast()+1);
65  delete th;
66  }
67  else
68  {
69  // do nothing
70  GO4TRACE((14,"TGo4ThreadHandler::~TGo4ThreadHandler() Non internal mode thread",__LINE__, __FILE__));
71  }
72  }// while(th=...)
73  delete fxIterator;
74  fxArray->Clear(); // remove objects from array, but do not delete them
75  delete fxArray;
76  }
77  delete fxListMutex;
78  delete fxOperMutex;
79 }
80 
81 
83 {
84  GO4TRACE((14,"TGo4ThreadHandler::AddThread(TGo4Thread*)",__LINE__, __FILE__));
85  Bool_t rev=kFALSE;
86  {
87  TGo4LockGuard listguard(fxListMutex);
88  if(fxArray->FindObject(gthr)==0)
89  // is thread already in list?
90  {
91  //no, add new thread
92  GO4TRACE((13,"TGo4ThreadHandler::AddThread(TGo4Thread*) Adding new go4 thread to array",__LINE__, __FILE__));
93  fxArray->AddLast(gthr);
94  rev=kTRUE;
95  }
96  else
97  {
98  // yes, do nothing
99  GO4TRACE((13,"TGo4ThreadHandler::AddThread(TGo4Thread*) Thread was already in array",__LINE__, __FILE__));
100  rev=kFALSE;
101  }
102  }
103  return rev;
104 }
105 
106 Bool_t TGo4ThreadHandler::RemoveThread (const char* name)
107 {
108  GO4TRACE((14,"TGo4ThreadHandler::RemoveThread(const char*)",__LINE__, __FILE__));
109  Bool_t rev=kFALSE;
110  {
111  TGo4LockGuard listguard(fxListMutex);
112  TObject* obj=fxArray->FindObject(name);
113  TGo4Thread* th= (TGo4Thread*) obj;
114  if(obj!=0)
115  // thread found, then remove it
116  {
117  GO4TRACE((13,"TGo4ThreadHandler::RemoveThread(const char*) Removing thread from array",__LINE__, __FILE__));
118  fxArray->Remove(obj);
119  fxArray->Compress();
120  fxArray->Expand(fxArray->GetLast()+1);
121  if(th->IsInternal())
122  // internal mode? then delete thread
123  {
124  GO4TRACE((13,"TGo4ThreadHandler::RemoveThread(const char*) Deleting internal mode thread",__LINE__, __FILE__));
125  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
126  fbIsOperating=kTRUE;
127  fxManager->UnBlockApp(); // tell blocking timer to enable system
128  delete th;
129  fbIsOperating=kFALSE;
130  fxManager->BlockApp(); // blocking again
131  }
132  else
133  {
134  // do nothing
135  GO4TRACE((13,"TGo4ThreadHandler::RemoveThread(const char*) Non internal mode thread is not deleted",__LINE__, __FILE__));
136  }
137  rev=kTRUE;
138  }
139  else
140  {
141  GO4TRACE((13,"TGo4ThreadHandler::RemoveThread(const char*) Thread not found in array",__LINE__, __FILE__));
142  rev=kFALSE;
143  }
144  }
145  return rev;
146 }
147 
148 Bool_t TGo4ThreadHandler::NewThread(const char* name, TGo4Runnable* runnable)
149 {
150  GO4TRACE((14,"TGo4ThreadHandler::NewThread(const char*,TGo4Runnable*)",__LINE__, __FILE__));
151  TGo4Runnable* nrun=0;
152  TGo4Thread* nthread=0;
153  if(runnable==0)
154  {
155  GO4TRACE((13,"TGo4ThreadHandler::NewThread(const char*,TGo4Runnable*) No runnable specified error",__LINE__, __FILE__));
156  return kFALSE;
157  //throw TGo4RuntimeException();
158  }
159  else
160  {
161  GO4TRACE((13,"TGo4ThreadHandler::NewThread(const char*,TGo4Runnable*) Assigning external runnable to new internal thread",__LINE__, __FILE__));
162  nrun=runnable;
163  }
164  nthread= new TGo4Thread(name,nrun,kTRUE);
165  return AddThread(nthread);
166 }
167 
169 {
170  GO4TRACE((15,"TGo4ThreadHandler::CreateAll()",__LINE__, __FILE__));
171  Int_t createdthreads=0; // return value: number of creation successes
172  TGo4Thread* th=0;
173  {
174  TGo4LockGuard listguard(fxListMutex); // protect thread list array
175  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
176  fbIsOperating=kTRUE;
177  fxManager->UnBlockApp(); // tell blocking timer to enable system
178  fxIterator->Reset();
179  while((th= (TGo4Thread*) fxIterator->Next())!=0)
180  {
181  if(th->Create())
182  {
183  GO4TRACE((13,"TGo4ThreadHandler::CreateAll() Thread creation success",__LINE__, __FILE__));
184  ++createdthreads; // increment success counter
185  }
186  else
187  {
188  GO4TRACE((13,"TGo4ThreadHandler::CreateAll() Thread not created",__LINE__, __FILE__));
189  // thread was already up, no new thread created
190  }
191  }
192  fxManager->BlockApp(); // tell blocking timer to enable system
193  fbIsOperating=kFALSE;
194  }
195  return createdthreads;
196 }
197 
198 Bool_t TGo4ThreadHandler::Create (const char* thname)
199 {
200  GO4TRACE((14,"TGo4ThreadHandler::Create(const char*)",__LINE__, __FILE__));
201  Bool_t rev=kFALSE;
202  TGo4Thread* th=GetThread(thname);
203  if(th!=0)
204  // thread was found in list
205  {
206  GO4TRACE((13,"TGo4ThreadHandler::Create(const char*) Creating new TThread for Go4Thread",__LINE__, __FILE__));
207  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
208  fbIsOperating=kTRUE;
209  fxManager->UnBlockApp(); // tell blocking timer to enable system
210  rev=th->Create();
211  fbIsOperating=kFALSE;
212  fxManager->BlockApp(); // block again afterwards
213  }
214  else
215  // no such thread
216  {
217  GO4TRACE((13,"TGo4ThreadHandler::Create(const char*) Go4Thread was not found in thread array!",__LINE__, __FILE__));
218  rev=kFALSE;
219  }
220  return rev;
221 }
222 
224 {
225  GO4TRACE((15,"TGo4ThreadHandler::CancelAll()",__LINE__, __FILE__));
226  Int_t cancelledthreads=0; // return value: number of successes
227  TGo4Thread* th=0;
228  {
229  TGo4LockGuard listguard(fxListMutex);
230  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
231  fbIsOperating=kTRUE;
232  fxIterator->Reset();
233  while((th= (TGo4Thread*) fxIterator->Next())!=0)
234  {
235  if(th->Cancel())
236  {
237  GO4TRACE((13,"TGo4ThreadHandler::CancelAll() Thread Cancel success",__LINE__, __FILE__));
238  ++cancelledthreads; // increment success counter
239  }
240  else
241  {
242  // thread was already down, not cancelled
243  GO4TRACE((13,"TGo4ThreadHandler::CancelAll() Thread was not canceled",__LINE__, __FILE__));
244 
245  }
246  }
247  fbIsOperating=kFALSE;
248  }
249  return cancelledthreads;
250 }
251 
252 Bool_t TGo4ThreadHandler::Cancel (const char* thname)
253 {
254  GO4TRACE((14,"TGo4ThreadHandler::Cancel(const char*)",__LINE__, __FILE__));
255  Bool_t rev=kFALSE;
256  TGo4Thread* th=GetThread(thname);
257  if(th!=0)
258  // go4thread was found in list
259  {
260  GO4TRACE((13,"TGo4ThreadHandler::Cancel(const char*) Canceling TThread",__LINE__, __FILE__));
261  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
262  fbIsOperating=kTRUE;
263  fxManager->UnBlockApp(); // tell blocking timer to enable system
264  rev=th->Cancel();
265  fbIsOperating=kFALSE;
266  fxManager->BlockApp(); // blocking again
267  }
268  else
269  // no such go4thread
270  {
271  GO4TRACE((13,"TGo4ThreadHandler::Cancel(const char*) Go4Thread was not found in thread array!",__LINE__, __FILE__));
272  rev=kFALSE;
273  }
274  return rev;
275 }
276 
278 {
279  GO4TRACE((15,"TGo4ThreadHandler::ReCreateAll()",__LINE__, __FILE__));
280  Int_t recreatedthreads=0; // return value: number of creation successes
281  TGo4Thread* th=0;
282  {
283  TGo4LockGuard listguard(fxListMutex);
284  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
285  fbIsOperating=kTRUE;
286  fxIterator->Reset();
287  while((th= (TGo4Thread*) fxIterator->Next())!=0)
288  {
289  if(th->ReCreate())
290  {
291  GO4TRACE((13,"TGo4ThreadHandler::ReCreateAll() Thread ReCreate success",__LINE__, __FILE__));
292  ++recreatedthreads; // increment success counter
293  }
294  else
295  {
296  // thread was already up, no new thread created
297  GO4TRACE((13,"TGo4ThreadHandler::ReCreateAll() Thread was not recreated",__LINE__, __FILE__));
298 
299  }
300  }
301  fbIsOperating=kFALSE;
302  }
303  return recreatedthreads;
304 }
305 
306 Bool_t TGo4ThreadHandler::ReCreate (const char* thname)
307 {
308  GO4TRACE((14,"TGo4ThreadHandler::ReCreate(const char*)",__LINE__, __FILE__));
309  Bool_t rev=kFALSE;
310  TGo4Thread* th=GetThread(thname);
311  if(th!=0)
312  // thread was found in list
313  {
314  GO4TRACE((13,"TGo4ThreadHandler::ReCreate(const char*) ReCreating TThread for Go4Thread",__LINE__, __FILE__));
315  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
316  fbIsOperating=kTRUE;
317  fxManager->UnBlockApp(); // tell blocking timer to enable system
318  rev=th->ReCreate();
319  fbIsOperating=kFALSE;
320  fxManager->BlockApp(); // block again afterwards
321  }
322  else
323  // no such thread
324  {
325  GO4TRACE((13,"TGo4ThreadHandler::ReCreate(const char*) Go4Thread was not found in thread array!",__LINE__, __FILE__));
326  rev=kFALSE;
327  }
328 
329  return rev;
330 }
331 
333 {
334  GO4TRACE((15,"TGo4ThreadHandler::StartAll()",__LINE__, __FILE__));
335  Int_t startedfuncs=0; // return value: number of successes
336  TGo4Thread* th=0;
337  {
338  TGo4LockGuard listguard(fxListMutex);
339  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
340  fbIsOperating=kTRUE; // Start has Create option, so we need gSystem
341  fxManager->UnBlockApp(); // tell blocking timer to enable system
342  fxIterator->Reset();
343  while((th= (TGo4Thread*) fxIterator->Next())!=0)
344  {
345  if(!th->Start())
346  // StartWork returns fbFuncrun status _before_ call
347  // false: Workfunc was started from stopped status
348  {
349  // false: Workfunc was started from stopped status
350  GO4TRACE((13,"TGo4ThreadHandler::StartAll() Thread Start success",__LINE__, __FILE__));
351  ++startedfuncs; // increment success counter
352  }
353  else
354  {
355  // true:
356  // function was already running before
357  GO4TRACE((13,"TGo4ThreadHandler::StartAll() Thread was already running",__LINE__, __FILE__));
358  }
359  }
360  fbIsOperating=kFALSE;
361  fxManager->BlockApp();
362  }
363  return startedfuncs;
364 }
365 
366 Bool_t TGo4ThreadHandler::Start (const char* thname)
367 {
368  GO4TRACE((14,"TGo4ThreadHandler::Start(const char*)",__LINE__, __FILE__));
369  Bool_t rev=kFALSE;
370  TGo4Thread* th=GetThread(thname);
371  if(th!=0)
372  // thread was found in list
373  {
374  GO4TRACE((13,"TGo4ThreadHandler::Start(const char*) Starting Thread",__LINE__, __FILE__));
375  TGo4LockGuard operguard(fxOperMutex); // protect operating flag
376  fbIsOperating=kTRUE; // Start has Create option, so we need gSystem
377  fxManager->UnBlockApp(); // tell blocking timer to enable system
378  rev=th->Start();
379  fbIsOperating=kFALSE;
380  fxManager->BlockApp(); // tell blocking timer to block system
381  }
382  else
383  // no such thread
384  {
385  GO4TRACE((13,"TGo4ThreadHandler::Start(const char*) Go4Thread was not found in thread array!",__LINE__, __FILE__));
386  rev=kFALSE;
387  }
388  return rev;
389 }
390 
392 {
393  GO4TRACE((15,"TGo4ThreadHandler::StopAll()",__LINE__, __FILE__));
394  Int_t stoppedfuncs=0; // return value: number of successes
395  TGo4Thread* th=0;
396  {
397  TGo4LockGuard listguard(fxListMutex);
398  fxIterator->Reset();
399  while((th= (TGo4Thread*) fxIterator->Next())!=0)
400  {
401  if(th->Stop())
402  // StopWork returns fbFuncrun status _before_ call
403  {
404  // true: Workfunc was stopped from running status
405  GO4TRACE((13,"TGo4ThreadHandler::StopAll() Go4Thread Stop success",__LINE__, __FILE__));
406  ++stoppedfuncs; // increment success counter
407  }
408  else
409  {
410  // false:
411  // function was already stopped before
412  GO4TRACE((13,"TGo4ThreadHandler::StopAll() Go4Thread was already stopped",__LINE__, __FILE__));
413  }
414  }
415  }
416  return stoppedfuncs;
417 }
418 
419 Bool_t TGo4ThreadHandler::Stop (const char* thname)
420 {
421  GO4TRACE((14,"TGo4ThreadHandler::Stop(const char*)",__LINE__, __FILE__));
422  Bool_t rev=kFALSE;
423  TGo4Thread* th=GetThread(thname);
424  if(th!=0)
425  // thread was found in list
426  {
427  GO4TRACE((13,"TGo4ThreadHandler::Stop(const char*) Stopping Go4Runnable",__LINE__, __FILE__));
428  rev=th->Stop();
429  }
430  else
431  // no such thread
432  {
433  GO4TRACE((13,"TGo4ThreadHandler::Stop(const char*) Go4Thread was not found in thread array!",__LINE__, __FILE__));
434  rev=kFALSE;
435  }
436  return rev;
437 }
438 
440 {
441  GO4TRACE((15,"TGo4ThreadHandler::DumpThreads(Int_t)",__LINE__, __FILE__));
442  if(TGo4Log::GetIgnoreLevel()>0) return 2; // only write threaddumpfile for debug mode
443  Int_t retval=0;
444  TGo4Thread* th=0;
445  FILE* fp;
446  Int_t i=0;
447  char Filename[80];
448  switch(mode)
449  {
450  case 0:
451  {
452  GO4TRACE((14,"TGo4ThreadHandler::DumpThreads(Int_t) mode 0: File output",__LINE__, __FILE__));
453  strcpy(Filename,"threaddump.txt");
454  fp = fopen(Filename,"w");
455  if (!fp)
456  {
457  GO4TRACE((13,"TGo4ThreadHandler::DumpThreads(Int_t) fopen failed!!",__LINE__, __FILE__));
458  TGo4Log::Debug(" ThreadHandler -- Error, Could not open thread dump file!");
459  retval=1;
460  break;
461  }
462  else
463  {
464  GO4TRACE((13,"TGo4ThreadHandler::DumpThreads(Int_t) writing into opened file",__LINE__, __FILE__));
465  fprintf(fp,"\nTGo4ThreadHandler thread information dump file:\n");
466  {
467  TGo4LockGuard listguard(fxListMutex);
468  fxIterator->Reset();
469  while((th= (TGo4Thread*) fxIterator->Next())!=0)
470  {
471  fprintf(fp,"TGo4Thread %d: \tPID:%d \tSelfID: %d",
472  i++,th->GetPID(),(int) th->GetSelfID());
473  fprintf(fp,"\t name: %s\n",th->GetName());
474  }
475  }
476  if (fclose(fp))
477  {
478  GO4TRACE((13,"TGo4ThreadHandler::DumpThreads(Int_t) fclose failed!!",__LINE__, __FILE__));
479  TGo4Log::Debug(" ThreadHandlerr -- Error, Could not close thread dump file!");
480  retval=1;
481  }
482  } // if(!fp)/else
483  }//case 0:
484  break;
485  default:
486  {
487  GO4TRACE((14,"TGo4ThreadHandler::DumpThreads(Int_t) mode: default ",__LINE__, __FILE__));
488  TGo4Log::Debug(" ThreadHandlerr -- Error: DumpThreads mode unknown ");
489  }
490  break;
491  }// switch(mode)
492  return retval;
493 }
494 
496 {
497  GO4TRACE((12,"TGo4ThreadHandler::GetThread(const char*)",__LINE__, __FILE__));
498  TGo4Thread* thread=0;
499  {
500  TGo4LockGuard listguard(fxListMutex);
501  thread = (TGo4Thread*) fxArray->FindObject(name);
502  }
503  return thread;
504 }
505 
507 {
508  GO4TRACE((12,"TGo4ThreadHandler::GetEntries()",__LINE__, __FILE__));
509  Int_t entries=0;
510  {
511  TGo4LockGuard listguard(fxListMutex);
512  entries=fxArray->GetEntries();
513  }
514  return entries;
515 }
516 
518 {
519  GO4TRACE((14,"TGo4ThreadHandler::AllCreated()",__LINE__, __FILE__));
520  Bool_t rev=kTRUE; // return value: false if one thread is not there
521  TGo4Thread* th=0;
522  {
523  TGo4LockGuard listguard(fxListMutex);
524  fxIterator->Reset();
525  while((th= (TGo4Thread*) fxIterator->Next())!=0)
526  {
527  if((th->GetPID())==0)
528  {
529  GO4TRACE((11,"TGo4ThreadHandler::AllCreated() TThread is _not_ existing",__LINE__, __FILE__));
530  rev=kFALSE; // this thread is not there
531  break;
532  }
533  else
534  {
535  GO4TRACE((11,"TGo4ThreadHandler::AllCreated() TThread is existing",__LINE__, __FILE__));
536  // thread PID found
537  }
538  } // while(th=...)
539  }
540  return rev;
541 }
542 
544 {
545  GO4TRACE((14,"TGo4ThreadHandler::AllRunning()",__LINE__, __FILE__));
546  Bool_t rev=kTRUE; // return value: false if one thread is not there
547  TGo4Thread* th=0;
548  {
549  TGo4LockGuard listguard(fxListMutex);
550  fxIterator->Reset();
551  while((th= (TGo4Thread*) fxIterator->Next())!=0)
552  {
553  if(!(th->IsRunning()))
554  {
555  GO4TRACE((11,"TGo4ThreadHandler::AllCreated() TGo4Thread is _not_ running",__LINE__, __FILE__));
556  rev=kFALSE; // this thread is not working
557  break;
558  }
559  else
560  {
561  GO4TRACE((11,"TGo4ThreadHandler::AllCreated() TGo4Thread is running",__LINE__, __FILE__));
562  // thread is working
563  }
564  }
565  }
566  return rev;
567 }
568 
570 {
571  GO4TRACE((14,"TGo4ThreadHandler::AllWaiting()",__LINE__, __FILE__));
572  Bool_t rev=kTRUE; // return value: false if one runnable is still running
573  TGo4Thread* th=0;
574  {
575  TGo4LockGuard listguard(fxListMutex);
576  fxIterator->Reset();
577  while((th= (TGo4Thread*) fxIterator->Next())!=0)
578  {
579  if(!(th->IsWaiting()))
580  {
581  GO4TRACE((11,"TGo4ThreadHandler::AllCreated() TGo4Thread is still running",__LINE__, __FILE__));
582  //std::cout <<"-------Thread "<<th->GetName()<<" is still running..." << std::endl;
583  rev=kFALSE; // this runnable is still doing
584  break;
585  }
586  else
587  {
588  GO4TRACE((11,"TGo4ThreadHandler::AllCreated() TGo4Thread is waiting",__LINE__, __FILE__));
589  // runnable is waiting
590  }
591  }
592  }
593  return rev;
594 }
Bool_t IsRunning() const
Definition: TGo4Thread.h:83
TGo4Thread * GetThread(const char *name)
Bool_t Stop()
Definition: TGo4Thread.cxx:328
TGo4ThreadManager * fxManager
Bool_t UnBlockApp(Int_t mode=0)
Bool_t Cancel()
Definition: TGo4Thread.cxx:187
Bool_t ReCreate(const char *thname)
Bool_t NewThread(const char *name, TGo4Runnable *runnable)
Bool_t IsWaiting() const
Definition: TGo4Thread.h:86
Int_t DumpThreads(Int_t mode=0)
Long_t GetSelfID() const
Definition: TGo4Thread.h:73
Bool_t IsInternal() const
Definition: TGo4Thread.h:77
Bool_t Create(const char *thname)
Bool_t Stop(const char *thname)
Bool_t Start(const char *thname)
Bool_t Cancel(const char *thname)
Bool_t ReCreate()
Definition: TGo4Thread.cxx:251
Bool_t Create()
Definition: TGo4Thread.cxx:167
#define GO4TRACE(X)
Definition: TGo4Log.h:26
static Int_t GetIgnoreLevel()
Definition: TGo4Log.cxx:342
Bool_t AddThread(TGo4Thread *gthr)
Bool_t Start()
Definition: TGo4Thread.cxx:307
Bool_t RemoveThread(const char *name)
Int_t GetPID() const
Definition: TGo4Thread.h:70
static void Debug(const char *text,...)
Definition: TGo4Log.cxx:284