---

/Go4DynamicList/TGo4DynamicList.cxx

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#include "TGo4DynamicList.h"

#include <iostream.h>
#include <stdexcept>

#include "TFolder.h"
#include "TMutex.h"

//#include "Go4LockGuard/TGo4LockGuard.h"
#include "Go4Log/TGo4Log.h"
#include "TGo4DynamicListStatus.h"
#include "TGo4DynamicListException.h"
#include "TGo4HistogramEntry.h"


TGo4DynamicList::TGo4DynamicList(const Text_t* name)
:TGo4DynamicEntry(name),fxList(0), fxListMutex(0), fxListIterator(0), fxTempFolder(0)
{
TRACE((15,"TGo4DynamicList::TGo4DynamicList(Text_t*, TGo4Condition*)",__LINE__, __FILE__));
   fxList=new TObjArray;
   fxListMutex=new TMutex(kTRUE);
   fxListIterator = fxList->MakeIterator();
   fxTempFolder=gROOT->GetRootFolder()->AddFolder("Go4Dynlist-tmp","The Go4 dynamic list temporary folder");
   fxTempFolder->SetOwner(kFALSE);
}


TGo4DynamicList::TGo4DynamicList()
:fxList(0), fxListMutex(0), fxListIterator(0), fxTempFolder(0)
{
  TRACE((15,"TGo4DynamicList::TGo4DynamicList()",__LINE__, __FILE__));
}



TGo4DynamicList::~TGo4DynamicList()
{
TRACE((15,"TGo4DynamicList::~TGo4DynamicList()",__LINE__, __FILE__));

if(fxTempFolder)
{
//   gROOT->GetListOfBrowsables()->Remove(fxTempFolder);
//   cout <<"removed dynlist tempfolder from browsables" << endl;
   gROOT->GetRootFolder()->Remove(fxTempFolder);
   delete fxTempFolder;
   fxTempFolder=0;
}
delete fxListIterator;
delete fxListMutex;
fxList->Delete();
delete fxList;

}


Int_t TGo4DynamicList::Process()
{
TRACE((12,"TGo4DynamicList::Process()",__LINE__, __FILE__));
   Int_t rev=0;
   TGo4DynamicEntry* entry=0;
   //TGo4LockGuard  listguard(fxListMutex);
try{
     TGo4DynamicEntry* errorentry=0;
     ResetIterator();
     while((entry= NextEntry() ) !=0)
      {
             try{ entry->Process();}
             catch(TGo4DynamicListException& ex)
               {
                  ex.Handle(); // will disable the error causing entry, continue other entries
                  errorentry= (TGo4DynamicEntry*) entry;
               }
      } // while
   if(errorentry) throw TGo4DynamicListException(errorentry,
               "!!!Dynamic List %s exception in process loop!!!", GetName());
}// try

catch(std::exception& ex) // treat standard library exceptions
{
   throw TGo4DynamicListException(entry,
               "!!!STD exception %s was raised processing dynamic entry of List %s!!!",
                  ex.what(), GetName());
}
return rev;
}


Bool_t TGo4DynamicList::AddEntry(TGo4DynamicEntry* en)
{
TRACE((12,"TGo4DynamicList::AddEntry(TGo4DynamicEntry*)",__LINE__, __FILE__));
if(en==0)
   return kFALSE;
// search if entry of that name exists:
const Text_t* newentryname= en->GetName();
TGo4DynamicEntry* oldentry=GetEntry(newentryname);
if(oldentry)
   {
      //oldentry of same name exists, do not add!
      return kFALSE;
   }
else
   {
      // no duplicate entry existing, add the new one
   //TGo4LockGuard listguard(fxListMutex);
      fxList->AddLast(en);
   return kTRUE;
   }

}


void TGo4DynamicList::DeleteEntry(const Text_t* name)
{
TRACE((12,"TGo4DynamicList::DeleteEntry(Text_t*)",__LINE__, __FILE__));
//TGo4LockGuard listguard(fxListMutex);
   TObject* ob= fxList->FindObject(name);
   fxList->Remove(ob);
   delete ob;
}

TGo4DynamicEntry * TGo4DynamicList::GetEntry(const Text_t* name)
{
TRACE((12,"TGo4DynamicList::GetEntry(Text_t*)",__LINE__, __FILE__));
//TGo4LockGuard listguard(fxListMutex);
   TObject* ob = fxList->FindObject(name);
   TGo4DynamicEntry * ent=dynamic_cast<TGo4DynamicEntry*>(ob);
   return ent;
}


TNamed * TGo4DynamicList::GetObject(const Text_t * name)
{
TRACE((12,"TGo4DynamicList::GetObject(Text_t*)",__LINE__, __FILE__));
//TGo4LockGuard listguard(fxListMutex);
   TNamed* ob=0;
   // redundant, since objects are kept now in TDirectories. do not implement!

   return ob;
}


void TGo4DynamicList::Clear(Option_t* option)
{
TRACE((12,"TGo4DynamicList::Clear(Option_t)",__LINE__, __FILE__));
//TGo4LockGuard listguard(fxListMutex);
   TString opt=option;
   if(opt.Contains("del"))
      fxList->Delete(option);
   else
      Reset();
}



void TGo4DynamicList::UpdateStatus(TGo4DynamicEntryStatus * state)
{
TRACE((12,"TGo4DynamicList::UpdateStatus(TGo4DynamicEntryStatus*)",__LINE__, __FILE__));
  if(!state)
     return;
  TGo4DynamicEntry::UpdateStatus(state);
  TGo4DynamicListStatus* liststate= dynamic_cast<TGo4DynamicListStatus*> (state);
   if (liststate)
      {
         TGo4DynamicEntry* entry=0;
         TList* nameslist= new TList;
         //TGo4LockGuard  listguard(fxListMutex);
         ResetIterator();
         while((entry= NextEntry() ) !=0)
            {
               TGo4DynamicEntryStatus* entrystate = entry->CreateStatus();
               nameslist->AddLast(entrystate);
            }
         if(fxTempFolder==0)
           {
               fxTempFolder=gROOT->GetRootFolder()->AddFolder("Go4Dynlist-tmp","The Go4 dynamic list temporary folder");
               fxTempFolder->SetOwner(kFALSE);
               //cout <<"created dynlist tempfolder in UpdateStatus " << endl;
           }
         //fxTempFolder->Clear();
         liststate->fxFolder=fxTempFolder->AddFolder(GetName(), GetTitle(), nameslist);
         liststate->fxFolder->SetOwner(kTRUE);
         fxTempFolder->Remove(liststate->fxFolder);
      }
   else
      {
         // dynamic cast failed! we have a different status class (never come here...)
      throw TGo4DynamicListException(this,
               "Dynamic List %s failed to Update Status: wrong status class %s  !!!",
                     GetName(), state->ClassName());
      }


}

TGo4DynamicEntryStatus* TGo4DynamicList::CreateStatus()
{
TRACE((12,"TGo4DynamicList::CreateStatus()",__LINE__, __FILE__));
//TGo4LockGuard listguard(fxListMutex);
   TGo4DynamicListStatus* state=new TGo4DynamicListStatus(GetName());
   UpdateStatus(state);
   return state;
}

void TGo4DynamicList::Reset()
{
TRACE((12,"TGo4DynamicList::Reset()",__LINE__, __FILE__));
  TGo4DynamicEntry::Reset();
  TGo4DynamicEntry* entry=0;
  //TGo4LockGuard  listguard(fxListMutex);
  ResetIterator();
  while((entry= NextEntry() ) !=0)
            {
               entry->Reset();
            }
}

void TGo4DynamicList::CleanupCondition(TGo4Condition * con)
{
TRACE((12,"TGo4DynamicList::CleanupConditin(TGo4Condition*)",__LINE__, __FILE__));
  TGo4DynamicEntry::CleanupCondition(con); // remove condition set on this list
  TGo4DynamicEntry* entry=0;
  //TGo4LockGuard  listguard(fxListMutex);
  ResetIterator();
  while((entry= NextEntry() ) !=0)
            {
               entry->CleanupCondition(con); // remove conditions in entries
            }
}

void TGo4DynamicList::CleanupHistogram(TH1 * his)
{
  TGo4DynamicEntry::CleanupHistogram(his); // currently a dummy call, later maybe not...
  TGo4DynamicEntry* entry=0;
  //TGo4LockGuard  listguard(fxListMutex);
  ResetIterator();
  while((entry= NextEntry() ) !=0)
      {
            entry->CleanupHistogram(his); // remove histograms in entries
      }
}

void TGo4DynamicList::SetStatus(TGo4DynamicEntryStatus * state)
{
   if(state==0) return;
   if(state->InheritsFrom("TGo4DynamicListStatus"))
      {
         //TGo4LockGuard  listguard(fxListMutex);
         TGo4DynamicEntry::SetStatus(state);
         TGo4DynamicListStatus* liststate= dynamic_cast<TGo4DynamicListStatus*>(state);
         TGo4DynamicEntryStatus* state=0;
         TList* statuslist= dynamic_cast<TList*>( liststate->GetTopFolder()->GetListOfFolders());
         TIterator* listiterator= statuslist->MakeIterator();
         while((state= dynamic_cast<TGo4DynamicEntryStatus*>( listiterator->Next() ) ) !=0)
            {
               SetEntryStatus(state->GetName(), state);
            }// while
         delete listiterator;
         TGo4DynamicEntry::SetStatus(liststate); // will also reset
      }
   else
      {
         throw TGo4DynamicListException(this,
               "Dynamic List %s failed to SetStatus: wrong status class %s !!!",
                     GetName(), state->ClassName());
      }


}

Bool_t TGo4DynamicList::SetEntryStatus(const Text_t* name, TGo4DynamicEntryStatus * state)
{
TRACE((12,"TGo4DynamicList::SetEntryStatus(Text_t*,TGo4DynamicEntryStatus*)",__LINE__, __FILE__));
   if(state==0) return kFALSE;
   Bool_t rev=kFALSE;
   TGo4DynamicEntry * ent=GetEntry(name);
   if(ent)
      {
         ent->SetStatus(state); // set status of exisiting entry
         rev=kTRUE;
      }
   else
      {
         ent=state->CreateDynamicEntry(); // add new entry created from state object
         rev=AddEntry(ent);
      }
   return rev;
}

TGo4DynamicEntryStatus * TGo4DynamicList::CreateEntryStatus(const Text_t * name)
{
TRACE((12,"TGo4DynamicList::CreateEntryStatus(Text_t*)",__LINE__, __FILE__));
   TGo4DynamicEntry * ent=GetEntry(name);
   if(ent)
      return (ent->CreateStatus());
   else
      return 0;
}

void TGo4DynamicList::CleanupEvent(TGo4EventElement * ev)
{
TRACE((12,"TGo4DynamicList::CleanupEvent(TGo4Eventelement*)",__LINE__, __FILE__));
 TGo4DynamicEntry::CleanupEvent(ev); // remove condition event set on this list
 TGo4DynamicEntry* entry=0;
 //TGo4LockGuard  listguard(fxListMutex);
 ResetIterator();
 while((entry= NextEntry())!=0)
            {
               entry->CleanupEvent(ev); // remove event in entries
            }

}

void TGo4DynamicList::ResetIterator()
{
//TGo4LockGuard listguard(fxListMutex);
if(fxList==0) return;
if(fxListIterator)
   fxListIterator->Reset();
else
   fxListIterator=fxList->MakeIterator();
}

TGo4DynamicEntry* TGo4DynamicList::NextEntry()
{
//TGo4LockGuard listguard(fxListMutex);
if(fxListIterator==0) return 0;
return ( dynamic_cast<TGo4DynamicEntry*>( fxListIterator->Next() ));
}



ClassImp(TGo4DynamicList)




//----------------------------END OF GO4 SOURCE FILE ---------------------

---